mammoth-cli 2.0.75__tar.gz → 2.0.76__tar.gz

{mammoth_cli-2.0.75 → mammoth_cli-2.0.76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.0.75
+Version: 2.0.76
 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.8,>=0.7.34
+Requires-Dist: mammoth-io<0.8,>=0.7.35
 Requires-Dist: platformdirs<5,>=4.10
 Requires-Dist: pydantic<3,>=2.12.5
 Requires-Dist: pyyaml<7,>=6

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

{mammoth_cli-2.0.75 → mammoth_cli-2.0.76}/mammoth_cli/bundled_skill/mammoth-cli/SKILL.md

@@ -29,16 +29,16 @@ mammoth doctor                          # auth, endpoint, connectivity, version;
 mammoth project ensure 'PROJECT NAME'   # get-or-create; becomes the active project
 ```
 
-`doctor` failing is a precondition failure, not a reason to proceed anyway.
+`doctor` failing is a precondition failure; never proceed anyway.
 When the connection check fails with a 502, 504 or timeout, `mammoth doctor
 --input '{"wait": 300}'` probes again for up to that many seconds; continue
 only once it passes. Production is the `app` endpoint; use `release` only
 when named, and check `meta.profile`/`auth status` `endpoint` match before
 continuing. If no profile has credentials, tell the operator to run
 `mammoth auth login` in their own terminal (add
-`--profile NAME` only for a profile other than `default`; [auth](references/auth.md)
+`--profile NAME` only if not `default`; [auth](references/auth.md)
 says where the token comes from) and wait; never ask for the token in chat,
-never read one from a file or environment variable, never run `auth login`
+never read one from a file/env var, never run `auth login`
 yourself. If any envelope carries `meta.update_available`, run its `command`
 before the next step.
 
@@ -51,8 +51,7 @@ before the next step.
 - The CLI remembers which dataset owns each view from any read (`view list
   DATASET_ID`, `view get VIEW_ID`, an upload). After that, no `dataset_id`
   on transforms, exports or deletes. If a command asks for the parent
-  `DATASET_ID`, read the view once and repeat it; an explicit value always
-  wins.
+  `DATASET_ID`, read the view once and repeat it; an explicit value wins.
 - Commands that start platform work wait up to 300 s for the job; on
   `timeout` use the `job get` recovery command printed, do not resubmit.
 
@@ -157,8 +156,8 @@ your report. If no column links the files, ask before you combine them.
   deliverables; cleanup is exact-ID authorized and
   never means delete-all-owned-resources: delete only ids this run created,
   one per call, and read back that they are gone.
-- A command whose schema lists `secret_fields` takes `--input FILE` (mode
-  0600); secrets never go in argv, notes, checkpoints or replies.
+- `secret_fields` commands send secrets via `--input`: 0600 FILE (shell)
+  or JSON (embedded); never in replies, notes, checkpoints or run logs.
 
 ## Verify before you report
 
@@ -166,7 +165,7 @@ your report. If no column links the files, ask before you combine them.
   change (set-values, filter, replace, join, fill) run `view data get
   VIEW_ID` (50 rows by default, `limit` to change) and check rows the
   condition should and should not have touched. Sample the target column
-  *before* the change for comparison.
+  before the change.
 - A uniform result (every amount 0, every region "Unknown", most join rows
   unmatched) means the previous step went wrong; stop and re-inspect it.
 - `column_warnings` on a data read and `join_check` on a join are findings,
@@ -175,13 +174,14 @@ your report. If no column links the files, ask before you combine them.
 - A timeout, exit 7 or interruption does not prove failure; reconcile an
   `outcome_unknown` (`job get`, `view task list`) before replaying.
 - Check an answer with no write against the question (a trend: time
-  buckets, a partial period named); no `project check`.
+  buckets, a partial period named; no `project check`); a reported number
+  comes from `calc`/`view data compare`, never mental math.
 - After a write, run `mammoth project check PROJECT_ID` and fix each
-  `to_report` line, or give it one line in the report.
+  `to_report` line, or note it in the report.
 - Run the [report checklist](references/report-checklist.md) before stating
   a number or calling a step done. When files disagree,
-  [capabilities](references/capabilities.md) wins over a recipe, which wins
-  over the generated catalog.
+  [capabilities](references/capabilities.md) wins over a recipe, then the
+  generated catalog.
 
 ## Route only what the task needs
 

{mammoth_cli-2.0.75 → mammoth_cli-2.0.76}/mammoth_cli/bundled_skill/mammoth-cli/references/about-mammoth.md

@@ -129,7 +129,8 @@ sort):
   {"cust_id": "Customer ID"}}`. The column keeps its internal name, so
   earlier tasks keep working; later commands, data reads, exports and
   dashboards use the new name. To name a column you create, use its
-  `new_column` or `as_name` field instead.
+  `new_column` or `as_name` field instead. Safe to call for a "just how it
+  looks" request -- it does not alter cell values.
 - **Sort the rows:** `view transform sort` with `{"order_by": [["Revenue",
   "DESC"]]}` (up to three columns; `[]` clears it). Data reads and exports
   return rows in this order. To keep only the top N rows, use `limit-rows`

{mammoth_cli-2.0.75 → mammoth_cli-2.0.76}/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 571; 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 573; 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:
 
@@ -14,6 +14,7 @@ Load only the applicable domain file:
 - [batch](commands/batch.md) — 7 published commands
 - [billing](commands/billing.md) — 23 published commands
 - [browse](commands/browse.md) — 4 published commands
+- [calc](commands/calc.md) — 1 published commands
 - [capability](commands/capability.md) — 3 published commands
 - [client-app](commands/client-app.md) — 5 published commands
 - [completion](commands/completion.md) — 2 published commands
@@ -45,7 +46,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) — 32 published commands
-- [view](commands/view.md) — 88 published commands
+- [view](commands/view.md) — 89 published commands
 - [webhook](commands/webhook.md) — 7 published commands
 - [workflow](commands/workflow.md) — 16 published commands
 - [workspace](commands/workspace.md) — 20 published commands

{mammoth_cli-2.0.75 → mammoth_cli-2.0.76}/mammoth_cli/bundled_skill/mammoth-cli/references/commands/automation.md

@@ -10,7 +10,7 @@ Example: `mammoth automation create 'Revenue report' --input '{"description": "s
 
 Result: `AutomationCreateResult`; mutation `external_effect`, confirmation `yes_always`, wait policy `not_async`.
 
-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. Created automation id=1 after two failed attempts: agent_example's run_data_retrieval needs cloud-source dataset ids (4AUTO006), and send_an_alert needed attachments.dataview_ids (undocume…
+Status on release: ran once on CLI 2.0.18 — fixture-lifecycle sweep 2026-09-19: exit 0 on CLI 2.0.18. Created automation id=1 after two failed attempts: run_data_retrieval needs cloud-source dataset ids (4AUTO006); send_an_alert needs attachments.dataview_ids, sent as CSV. Single invocation only.
 
 ### `automation.delete`
 

mammoth_cli-2.0.76/mammoth_cli/bundled_skill/mammoth-cli/references/commands/calc.md

@@ -0,0 +1,13 @@
+# `calc` commands
+
+Every command returns the standard JSON envelope. On nonzero exit, read the error envelope and its `recovery_commands`; do not guess request fields. "Status on release" is joined from `docs/release-capability-matrix.json`: *ran once* means one bounded live run succeeded on the named CLI release, *untried* means nobody has run it, *not supported* means the backend refuses it. When this file disagrees with [capabilities](../capabilities.md) or a recipe, they win. Envelope shapes: [machine output](../machine-output.md).
+
+### `calc`
+
+Run: `mammoth calc`. Exact input fields: `mammoth schema get calc`.
+
+Example: `mammoth calc '2063664 - 1917815'`. Placeholders are illustrative; resolve IDs and input from observed reads.
+
+Result: `CalcResult`; mutation `read`, confirmation `none`, wait policy `not_async`.
+
+Status on release: untried; no live run recorded.

{mammoth_cli-2.0.75 → mammoth_cli-2.0.76}/mammoth_cli/bundled_skill/mammoth-cli/references/commands/view.md

@@ -222,6 +222,16 @@ Result: `ViewDataAggregateResult`; mutation `read`, confirmation `none`, wait po
 
 Status on release: untried; no live run recorded.
 
+### `view.data.compare`
+
+Run: `mammoth view data compare`. Exact input fields: `mammoth schema get view.data.compare`.
+
+Example: `mammoth view data compare 111 222 --input '{"group_by": ["Campaign"], "aggregations": [{"column": "Spend", "function": "SUM", "as_name": "Spend"}]}'`. Placeholders are illustrative; resolve IDs and input from observed reads.
+
+Result: `ViewDataCompareResult`; mutation `read`, confirmation `none`, wait policy `not_async`.
+
+Status on release: untried; no live run recorded.
+
 ### `view.data.explore`
 
 Run: `mammoth view data explore`. Exact input fields: `mammoth schema get view.data.explore`.

{mammoth_cli-2.0.75 → mammoth_cli-2.0.76}/mammoth_cli/bundled_skill/mammoth-cli/references/commands/workspace.md

@@ -138,9 +138,9 @@ Status on release: untried; no live run recorded.
 
 Run: `mammoth workspace user add`. Exact input fields: `mammoth schema get workspace.user.add`.
 
-Example: `mammoth workspace user add --input '{"email_ids": ["analyst@example.com"]}'`. Placeholders are illustrative; resolve IDs and input from observed reads.
+Example: `mammoth workspace user add --yes --input '{"email_ids": ["analyst@example.com"]}'`. Illustrative only: append `--yes` after observing an owned target.
 
-Result: `WorkspaceUserAddResult`; mutation `benign_mutation`, confirmation `none`, wait policy `not_async`.
+Result: `WorkspaceUserAddResult`; mutation `benign_mutation`, confirmation `yes_always`, wait policy `not_async`.
 
 Status on release: untried; no live run recorded.
 

{mammoth_cli-2.0.75 → mammoth_cli-2.0.76}/mammoth_cli/bundled_skill/mammoth-cli/references/recipes/exports.md

@@ -45,6 +45,12 @@ mammoth view export dataset SOURCE_VIEW_ID SOURCE_DATASET_ID --yes \
 mammoth view export list SOURCE_VIEW_ID SOURCE_DATASET_ID     # handler internal_dataset, status executed, TARGET_DS_ID N
 ```
 
+The product's per-destination "Export Auto-Sync" toggle is this same
+pipeline-step behavior seen from the UI: it is the CLI's `trigger_type`
+(default `pipeline`; pass `"none"` to turn Auto-Sync off) and `run_immediately`
+(whether it also executes once now) fields on the typed export commands —
+there is no separate Auto-Sync endpoint or field to find.
+
 `target_ds_id` writes into an existing dataset instead of creating one
 (`save_as_mode` `REPLACE_IN_DS` or `APPEND_TO_DS`). Read the delivery back in
 the target project (`view list N --project P`, `view data get`) before
@@ -58,10 +64,20 @@ reporting it. Do not build this with `view export create`: the raw
 `schema get` lists `secret_fields` for every typed destination export
 (`postgres`, `mysql`, `mssql`, `redshift`, `elasticsearch`, `ftp`, `sftp`,
 `powerbi`, `tableau`, `azure-blob`, `onedrive`, `sharepoint`, `rest`). When
-that list is non-empty the request body is written by the operator to a
-`0600` file and passed as `--input FILE`; it is never an inline document and
-never appears in argv, the run log, or a checkpoint. The connector command is
-`external_effect` with `confirmation: yes_always`, so `--yes` is required.
+that list is non-empty:
+
+- In a shell, the operator writes the request body to a `0600` file and
+  passes it as `--input FILE` -- never an inline document, and never in
+  argv.
+- Embedded in a product with no shell and no file system (see
+  `mammoth_cli.embed.invoke`), where every write is shown to the user on a
+  confirmation card before it runs, the secret goes in the `--input`
+  JSON's credential field instead: a password or token the user supplies
+  for their own destination is used there, behind the card.
+
+In every case the secret never appears in a reply, a note, a checkpoint, or
+the run log. The connector command is `external_effect` with
+`confirmation: yes_always`, so `--yes` is required.
 
 ```bash
 mammoth schema get view.export.postgres   # read secret_fields, required fields

{mammoth_cli-2.0.75 → mammoth_cli-2.0.76}/mammoth_cli/bundled_skill/mammoth-cli/references/recipes/scheduling.md

@@ -52,7 +52,10 @@ automation.create` under `tasks[].details`:
 
 - `append_data`: `destination_dataset_ids` (required) plus either
   `source_folder_resource_id` or `source_dataset_id`.
-- `send_an_alert`: `alert_type` ("email"), `recipients`, `subject`.
+- `send_an_alert`: `alert_type` ("email"), `recipients`, `subject`, and optional
+  `attachments.dataview_ids` (a list of view ids); each attached view is
+  emailed as a CSV file, combined row count capped at 100,000 across all
+  attachments.
 - `pull_cloud_files`: `connector_key`, `connection_key`,
   `cloud_source_folder_path`, `destination_folder_resource_id`.
 

{mammoth_cli-2.0.75 → mammoth_cli-2.0.76}/mammoth_cli/bundled_skill/mammoth-cli/references/report-checklist.md

@@ -16,5 +16,7 @@ Every "yes" must point at a command you ran in this task and its response.
 | List cleanup ids and read each one back | one id per destructive call, each followed by a `list`/`get` that no longer shows it; the final list of what remains |
 | Nothing in the report is a secret or an unredacted body | no keys, tokens, `--input` documents for `secret_fields` commands, or raw error bodies |
 | Name every unknown outcome | any exit 7 / `outcome_unknown` with the id or job it may have created |
+| A "can X do Y" answer leads with the real limitation, not an unqualified "Yes" when only an alternative exists | the caveat or alternative is the first clause of the answer, not an afterthought |
+| A capability you describe by a command you looked up names that command's own words | the reply uses the term from its purpose text or `action` field (e.g. `view ai profile` -> "profile"/"insights") so the user can find it in the app |
 
 If you cannot satisfy a row, say so in the report instead of omitting it.

{mammoth_cli-2.0.75 → mammoth_cli-2.0.76}/mammoth_cli/commands/addon.py

@@ -20,6 +20,7 @@ from typing import Any
 from mammoth_cli.errors.envelope import (
     CODE_MISSING_FIELD,
     CODE_SDK_SYMBOL_UNRESOLVED,
+    CODE_UNSUPPORTED_CONTRACT,
     EXIT_USAGE,
     CliError,
 )
@@ -114,10 +115,22 @@ def addon_connector_remove(invocation: Invocation) -> HandlerResult:
 
 
 def addon_list(invocation: Invocation) -> HandlerResult:
-    """List active addons for the workspace."""
-    with open_service(invocation) as (service, auth):
-        data = service.call(_symbol(invocation))
-    return data, _meta(invocation, auth.workspace_id)
+    """List active addons for the workspace.
+
+    RCA T1-W-17: ``GET /workspaces/{id}/addons`` has no backing route on the
+    backend at all (a 404 from Litestar's own routing trie, not a typed
+    error) -- fail loud with that fact up front rather than surface the raw
+    404 as if the call had merely found nothing.
+    """
+    raise CliError(
+        code=CODE_UNSUPPORTED_CONTRACT,
+        message=(
+            "addon list has no backend route (GET /workspaces/{workspace_id}/addons does not "
+            "exist) and always 404s; it is currently non-functional."
+        ),
+        exit_status=EXIT_USAGE,
+        hint="Use `billing chargebee-plan` or `billing subscription get` for plan/storage info.",
+    )
 
 
 def addon_storage_add(invocation: Invocation) -> HandlerResult:

mammoth_cli-2.0.76/mammoth_cli/commands/calc.py

@@ -0,0 +1,124 @@
+"""The ``calc`` command: local, read-only, exact arithmetic.
+
+T2-WPP-W8: an agent ran ``view data aggregate`` on two views and subtracted
+the totals mentally, reporting 45,849 where the true difference was 145,849
+(2,063,664 - 1,917,815) -- a transcription/mental-math error a machine never
+makes. Every number an agent reports must come from a tool result, never
+mental arithmetic; ``calc`` is that tool for a single expression (``view
+data compare`` is the tool for a per-key comparison across two views).
+
+The expression is parsed with :mod:`ast` and only a small, explicitly
+allowed set of node types is walked -- never Python's ``eval()``. All
+arithmetic is :class:`decimal.Decimal`, so results are exact, not a float
+approximation.
+"""
+
+from __future__ import annotations
+
+import ast
+import re
+from collections.abc import Callable
+from decimal import ROUND_HALF_UP, Decimal, DivisionByZero, InvalidOperation
+from typing import Any
+
+from mammoth_cli.errors.envelope import CODE_INVALID_ARGUMENT, EXIT_USAGE, CliError
+from mammoth_cli.runtime.invocation import Invocation
+
+HandlerResult = tuple[Any, dict[str, Any]]
+
+#: A trailing "N%" is rewritten to "(N/100)" before parsing -- ``%`` is not
+#: valid Python expression syntax on its own.
+_PERCENT_RE = re.compile(r"(\d+(?:\.\d+)?)\s*%")
+
+_BINOPS: dict[type, Callable[[Decimal, Decimal], Decimal]] = {
+    ast.Add: lambda a, b: a + b,
+    ast.Sub: lambda a, b: a - b,
+    ast.Mult: lambda a, b: a * b,
+    ast.Div: lambda a, b: a / b,
+}
+
+
+def _unsupported(expression: str) -> CliError:
+    return CliError(
+        code=CODE_INVALID_ARGUMENT,
+        message=f"Unsupported syntax in {expression!r}.",
+        exit_status=EXIT_USAGE,
+        hint="calc supports + - * / and parentheses, unary +/-, a trailing "
+        "'%' (divides by 100), and round(x[, ndigits]).",
+    )
+
+
+def _evaluate(node: ast.AST, expression: str) -> Decimal:
+    if isinstance(node, ast.Expression):
+        return _evaluate(node.body, expression)
+    if (
+        isinstance(node, ast.Constant)
+        and isinstance(node.value, (int, float))
+        and not isinstance(node.value, bool)
+    ):
+        return Decimal(str(node.value))
+    if isinstance(node, ast.BinOp) and type(node.op) in _BINOPS:
+        left = _evaluate(node.left, expression)
+        right = _evaluate(node.right, expression)
+        try:
+            return _BINOPS[type(node.op)](left, right)
+        except (InvalidOperation, DivisionByZero, ZeroDivisionError) as exc:
+            raise CliError(
+                code=CODE_INVALID_ARGUMENT,
+                message=f"Division by zero in {expression!r}.",
+                exit_status=EXIT_USAGE,
+            ) from exc
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub)):
+        value = _evaluate(node.operand, expression)
+        return value if isinstance(node.op, ast.UAdd) else -value
+    if (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "round"
+        and not node.keywords
+        and 1 <= len(node.args) <= 2
+    ):
+        value = _evaluate(node.args[0], expression)
+        ndigits = 0
+        if len(node.args) == 2:
+            digits_node = node.args[1]
+            if not (
+                isinstance(digits_node, ast.Constant)
+                and isinstance(digits_node.value, int)
+                and not isinstance(digits_node.value, bool)
+            ):
+                raise _unsupported(expression)
+            ndigits = digits_node.value
+        quantum = Decimal(1).scaleb(-ndigits)
+        return value.quantize(quantum, rounding=ROUND_HALF_UP)
+    raise _unsupported(expression)
+
+
+def calc(invocation: Invocation) -> HandlerResult:
+    """Evaluate one arithmetic expression exactly.
+
+    The sole positional argument is the expression: ``+ - * /``,
+    parentheses, unary ``+``/``-``, a trailing ``%`` (divides by 100), and
+    ``round(x[, ndigits])``. Returns the expression and its exact
+    :class:`~decimal.Decimal` result as a string.
+    """
+    expression = invocation.extra_args[0] if invocation.extra_args else None
+    if not expression or not expression.strip():
+        raise CliError(
+            code=CODE_INVALID_ARGUMENT,
+            message="calc requires an expression argument, e.g. '2063664 - 1917815'.",
+            exit_status=EXIT_USAGE,
+        )
+    normalized = _PERCENT_RE.sub(r"(\1/100)", expression)
+    try:
+        tree = ast.parse(normalized, mode="eval")
+    except SyntaxError as exc:
+        raise CliError(
+            code=CODE_INVALID_ARGUMENT,
+            message=f"Could not parse {expression!r}: {exc.msg}.",
+            exit_status=EXIT_USAGE,
+            hint="calc supports + - * / and parentheses, unary +/-, a trailing "
+            "'%' (divides by 100), and round(x[, ndigits]).",
+        ) from exc
+    result = _evaluate(tree, expression)
+    return {"expression": expression, "result": str(result)}, {}

{mammoth_cli-2.0.75 → mammoth_cli-2.0.76}/mammoth_cli/commands/dataset.py

@@ -184,8 +184,9 @@ def dataset_find(invocation: Invocation) -> HandlerResult:
     return {
         "matches": matches,
         "projects_searched": len(projects),
-        "projects_truncated": invocation.project is None
-        and len(projects) >= _MAX_PROJECTS_SEARCHED,
+        "projects_truncated": (
+            invocation.project is None and len(projects) >= _MAX_PROJECTS_SEARCHED
+        ),
     }, meta
 
 
@@ -200,15 +201,82 @@ def dataset_list(invocation: Invocation) -> HandlerResult:
     return data, _meta(invocation, auth.workspace_id, project_id)
 
 
+def _export_write_hint(data: dict[str, Any]) -> str | None:
+    """Name the recurring export that writes into this dataset, if any.
+
+    A dataset produced by ``view export dataset`` carries its source view and
+    export ids in ``additional_info`` (``DATAVIEW_ID``/``TRIGGER_ID`` — an
+    export is a ``DataviewActionTrigger`` row, so ``TRIGGER_ID`` is exactly the
+    ``export_id`` argument ``view export delete`` takes). Deleting the dataset
+    does not stop that export from writing into it again; name the export and
+    the command that stops it (T1-O-10: an agent deleted the dataset instead).
+    """
+    additional_info = data.get("additional_info")
+    if not isinstance(additional_info, dict):
+        return None
+    dataview_id = additional_info.get("DATAVIEW_ID")
+    export_id = additional_info.get("TRIGGER_ID")
+    if not isinstance(dataview_id, int) or not isinstance(export_id, int):
+        return None
+    return (
+        f"This dataset is written by a recurring export from view {dataview_id} "
+        f"(export {export_id}); deleting the dataset does not stop the export. "
+        f"Run 'mammoth view export delete {dataview_id} {export_id}' to stop it."
+    )
+
+
+def _zero_view_hint(dataset_id: int) -> str:
+    """Name the fix for a dataset with no queryable views yet (T1-I-13).
+
+    Nothing is queryable until a view exists (transforms, joins, exports and
+    previews all take a view id, not a dataset id) — an agent that only reads
+    dataset-level metadata and never sees a zero view count can conclude "no
+    correction needed" while nothing it changed is visible anywhere.
+    """
+    return (
+        f"This dataset has no views yet; nothing is queryable until one exists. "
+        f"Run 'mammoth view create {dataset_id}' to create one."
+    )
+
+
 def dataset_get(invocation: Invocation) -> HandlerResult:
     """Get one dataset by id in the active project."""
     project_id = require_project(invocation)
     dataset_id = _require_int_positional(invocation, "dataset id")
     with open_service(invocation) as (service, auth):
         data = service.call(_symbol(invocation), dataset_id=dataset_id, project_id=project_id)
+        views = service.call(
+            "mammoth.api.dataviews.DataviewsAPI.list",
+            dataset_id=dataset_id,
+            project_id=project_id,
+        )
+    _strip_file_ingestion_automation_possible(data)
+    hint = _export_write_hint(data) if isinstance(data, dict) else None
+    if isinstance(data, dict) and isinstance(views, dict):
+        view_count = len(views.get("dataviews") or [])
+        data = {**data, "view_count": view_count}
+        if view_count == 0:
+            zero_hint = _zero_view_hint(dataset_id)
+            hint = f"{hint} {zero_hint}" if hint else zero_hint
+    if hint is not None:
+        data = {**data, "hint": hint}
     return data, _meta(invocation, auth.workspace_id, project_id)
 
 
+def _strip_file_ingestion_automation_possible(data: Any) -> None:
+    """Drop ``automation_possible`` (T1-R-01/T1-R-07): CSV-ingestion metadata
+    about whether the header-parsing pipeline can auto-process this upload
+    (``api/api/file/unprocessed.py``), unrelated to whether the dataset has a
+    connector to put on a scheduled refresh. Left in, an agent checking a
+    dataset's automation options reads it as contradicting a correct "no
+    refreshable source" claim."""
+    if not isinstance(data, dict):
+        return
+    params = data.get("additional_info", {}).get("all_data_backup", {}).get("PARAMS", {})
+    if isinstance(params, dict):
+        params.pop("automation_possible", None)
+
+
 def dataset_data(invocation: Invocation) -> HandlerResult:
     """Fetch a dataset's data, waiting for the backing job to complete."""
     project_id = require_project(invocation)
@@ -432,11 +500,21 @@ def dataset_delete(invocation: Invocation) -> HandlerResult:
     """Permanently delete one dataset by id. Prompt or ``--yes`` required."""
     project_id = require_project(invocation)
     dataset_id = _require_int_positional(invocation, "dataset id")
-    enforce_confirmation(
-        invocation, policy=POLICY_PROMPT_OR_YES, action=f"delete dataset {dataset_id}"
-    )
+    action = f"delete dataset {dataset_id}"
     with open_service(invocation) as (service, auth):
+        # A read, not a mutation: the dry-run gate lets it through so the
+        # confirmation message below can name the export writing into this
+        # dataset (T1-O-10), the same as a real run would see.
+        preview = service.call(
+            "mammoth.api.datasets.DatasetsAPI.get", dataset_id=dataset_id, project_id=project_id
+        )
+        hint = _export_write_hint(preview) if isinstance(preview, dict) else None
+        if hint is not None:
+            action = f"{action}. {hint}"
+        enforce_confirmation(invocation, policy=POLICY_PROMPT_OR_YES, action=action)
         data = service.call(_symbol(invocation), dataset_id=dataset_id, project_id=project_id)
+    if hint is not None and isinstance(data, dict):
+        data = {**data, "hint": hint}
     return data, _meta(invocation, auth.workspace_id, project_id)
 
 

{mammoth_cli-2.0.75 → mammoth_cli-2.0.76}/mammoth_cli/commands/registry.py

@@ -26,6 +26,7 @@ from mammoth_cli.commands import automation as automation_cmd
 from mammoth_cli.commands import batch as batch_cmd
 from mammoth_cli.commands import billing as billing_cmd
 from mammoth_cli.commands import browse as browse_cmd
+from mammoth_cli.commands import calc as calc_cmd
 from mammoth_cli.commands import capability as capability_cmd
 from mammoth_cli.commands import client_app as client_app_cmd
 from mammoth_cli.commands import completion as completion_cmd
@@ -231,6 +232,7 @@ HANDLERS: dict[str, Handler] = {
     "log.path": _log_path,
     "log.tail": _log_tail,
     "doctor": doctor_cmd.doctor,
+    "calc": calc_cmd.calc,
     "completion.show": completion_cmd.completion_show,
     "completion.install": completion_cmd.completion_install,
     "skill.agents-md.install": skill_cmd.skill_agents_md_install,
@@ -644,6 +646,7 @@ HANDLERS: dict[str, Handler] = {
     "view.data.get": view_cmd.view_data_get,
     "view.data.query": view_cmd.view_data_query,
     "view.data.aggregate": view_cmd.view_data_aggregate,
+    "view.data.compare": view_cmd.view_data_compare,
     "view.data.explore": view_cmd.view_data_explore,
     "view.exportable-config.get": view_cmd.view_exportable_config_get,
     "view.exportable-config.apply": view_cmd.view_exportable_config_apply,