mammoth-cli 2.2.53__tar.gz → 2.2.55__tar.gz

{mammoth_cli-2.2.53 → mammoth_cli-2.2.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.2.53
+Version: 2.2.55
 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.27
+Requires-Dist: mammoth-io<0.9,>=0.8.29
 Requires-Dist: platformdirs<5,>=4.10
 Requires-Dist: pydantic<3,>=2.12.5
 Requires-Dist: pyyaml<7,>=6

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

{mammoth_cli-2.2.53 → mammoth_cli-2.2.55}/mammoth_cli/__main__.py

@@ -8,10 +8,9 @@ launch symbol that does not change when the application wiring moves.
 
 from __future__ import annotations
 
+import sys
 from typing import Any
 
-from mammoth_cli.app import app
-
 
 def main() -> Any:
     """Run the Mammoth CLI application.
@@ -20,6 +19,16 @@ def main() -> Any:
         The value returned by the Typer application, which the runtime uses as
         the process exit code.
     """
+    if sys.argv[1:] == ["--version"]:
+        # The answer needs none of the command tree; skip building it.
+        from mammoth_cli import __version__
+
+        sys.stdout.write(f"{__version__}\n")
+        return 0
+    from mammoth_cli.app import app
+    from mammoth_cli.context import keyring_backend
+
+    keyring_backend.enable()
     return app()
 
 

{mammoth_cli-2.2.53 → mammoth_cli-2.2.55}/mammoth_cli/app.py

@@ -15,23 +15,25 @@ positionals and options are added per family as each handler is implemented.
 from __future__ import annotations
 
 import inspect
+import json
 import re
 import sys
 from collections.abc import Callable, Sequence
 from dataclasses import replace
+from difflib import get_close_matches
 from functools import cache
-from typing import Annotated, Any
+from pathlib import Path
+from typing import TYPE_CHECKING, Annotated, Any, cast
 
 import typer
 from typer._click import exceptions as _typer_click_exceptions
 from typer._click.core import Command as _ClickCommand
-from typer.core import TyperGroup
+from typer._click.core import Parameter as _ClickParameter
+from typer.core import TyperCommand, TyperGroup
 
 from mammoth_cli import __version__
 from mammoth_cli.commands import BESPOKE
-from mammoth_cli.commands.registry import HANDLERS, Handler
-from mammoth_cli.commands.schema import IN_PLACE_RECIPE, edits_view_in_place
-from mammoth_cli.context import profiles
+from mammoth_cli.commands.registry import HANDLERS
 from mammoth_cli.errors.envelope import EXIT_USAGE, CliError, not_implemented_error
 from mammoth_cli.manifest.loader import command_by_id, load_commands
 from mammoth_cli.output.policy import (
@@ -42,17 +44,12 @@ from mammoth_cli.output.policy import (
     VALID_OUTPUTS,
     resolve_output,
 )
-from mammoth_cli.runtime import executor, validate
-from mammoth_cli.runtime.dataset_health import with_dataset_health
-from mammoth_cli.runtime.intent_only import refuse_hand_crafted_write
-from mammoth_cli.runtime.invocation import Invocation
-from mammoth_cli.runtime.locked_files import with_locked_files
-from mammoth_cli.runtime.new_data import with_new_data_path
-from mammoth_cli.runtime.state import with_state
-from mammoth_cli.runtime.strict import validate_extra_args
-from mammoth_cli.runtime.verify import with_verify
 from mammoth_cli.services.positionals import PositionalSpec, resolve_positionals
 
+if TYPE_CHECKING:
+    from mammoth_cli.commands.registry import Handler
+    from mammoth_cli.runtime.invocation import Invocation
+
 OUTPUT_MODES = VALID_OUTPUTS
 
 # Root help is the first piece of discovery most people (and agents) see.  The
@@ -369,7 +366,7 @@ class _EnvelopeGroup(TyperGroup):
         loaded: dict[str, Any] = self.__dict__.setdefault("_eager_commands", {})
         for name in _LAZY_GROUP_NAMES:
             if name not in loaded:
-                loaded[name] = _load_top_level_group(name)
+                loaded[name] = _load_lazy_root(name)
         return loaded
 
     @commands.setter
@@ -378,14 +375,42 @@ class _EnvelopeGroup(TyperGroup):
 
     def list_commands(self, ctx: Any) -> list[str]:
         eager = self.__dict__.get("_eager_commands", {})
-        return [*eager, *(name for name in _LAZY_GROUP_NAMES if name not in eager)]
+        # Top-level leaves list ahead of groups, the order they were registered in.
+        lazy = sorted(_LAZY_GROUP_NAMES, key=lambda name: name not in _LAZY_LEAF_IDS)
+        return [*eager, *(name for name in lazy if name not in eager)]
 
     def get_command(self, ctx: Any, cmd_name: str) -> Any:
         eager: dict[str, Any] = self.__dict__.setdefault("_eager_commands", {})
         if cmd_name not in eager and cmd_name in _LAZY_GROUP_NAMES:
-            eager[cmd_name] = _load_top_level_group(cmd_name)
+            if self.__dict__.get("_listing_help"):
+                if cmd_name in _LAZY_LEAF_IDS:
+                    return _root_leaf_stub(cmd_name)
+                return _group_stub(cmd_name)
+            eager[cmd_name] = _load_lazy_root(cmd_name)
         return eager.get(cmd_name)
 
+    def resolve_command(self, ctx: Any, args: list[str]) -> Any:
+        # Typer's override suggests close names from ``self.commands``, which
+        # builds every group; the names alone are all a suggestion needs.
+        try:
+            return self._click_resolve_command(ctx, args)
+        except _typer_click_exceptions.UsageError as error:
+            if self.suggest_commands and args:
+                matches = get_close_matches(args[0], self.list_commands(ctx))
+                if matches:
+                    suggestions = ", ".join(f"{m!r}" for m in matches)
+                    error.message = f"{error.message.rstrip('.')}. Did you mean {suggestions}?"
+            raise
+
+    def format_help(self, ctx: Any, formatter: Any) -> None:
+        # Root ``--help`` only needs each group's name, panel and one-line
+        # description; building all ~550 commands to print them cost seconds.
+        self.__dict__["_listing_help"] = True
+        try:
+            super().format_help(ctx, formatter)
+        finally:
+            self.__dict__["_listing_help"] = False
+
     def main(self, *args: Any, **kwargs: Any) -> Any:
         if not kwargs.get("standalone_mode", True):
             return super().main(*args, **kwargs)
@@ -447,11 +472,16 @@ class _EnvelopeGroup(TyperGroup):
                     )
                 elif isinstance(error, _typer_click_exceptions.NoSuchOption):
                     option = getattr(error, "option_name", None) or "unknown"
+                    close = getattr(error, "possibilities", None) or []
                     report = CliError(
                         code="unknown_option",
                         message=f"Unknown option '{option}'.",
                         exit_status=EXIT_USAGE,
-                        hint="Check the command schema with 'mammoth schema get'.",
+                        hint=(
+                            f"Did you mean {' or '.join(sorted(close))}?"
+                            if close
+                            else "Check the command schema with 'mammoth schema get'."
+                        ),
                         details={"option": option},
                     )
                 elif isinstance(error, _typer_click_exceptions.BadParameter):
@@ -496,6 +526,8 @@ class _EnvelopeGroup(TyperGroup):
                         exit_status=EXIT_USAGE,
                         hint="Check the command schema with 'mammoth schema get'.",
                     )
+            from mammoth_cli.runtime import executor
+
             executor.emit_error(report, machine=True)
         elif report is None:
             error.show()
@@ -820,6 +852,8 @@ def _build_leaf(command_id: str, *, is_group_callback: bool = False) -> Callable
     positional_names = tuple(spec.name for spec in positionals)
 
     def leaf(**params: Any) -> None:
+        from mammoth_cli.runtime.invocation import Invocation
+
         ctx: typer.Context = params.pop("ctx")
         if is_group_callback and ctx.invoked_subcommand is not None:
             return
@@ -853,6 +887,14 @@ def _execute(invocation: Invocation) -> None:
     # Freeze the fallback profile before opening a service.  A recovery command
     # must inspect the same account that submitted/observed a job, rather than
     # resolving the mutable selected-profile pointer after an interrupt.
+    from mammoth_cli.context import profiles
+    from mammoth_cli.runtime import executor, validate
+    from mammoth_cli.runtime.dataset_health import with_dataset_health
+    from mammoth_cli.runtime.intent_only import refuse_hand_crafted_write
+    from mammoth_cli.runtime.locked_files import with_locked_files
+    from mammoth_cli.runtime.new_data import with_new_data_path
+    from mammoth_cli.runtime.strict import validate_extra_args
+
     if invocation.profile is None:
         invocation = replace(invocation, profile=profiles.get_selected())
 
@@ -908,6 +950,9 @@ def _apply_verify(invocation: Invocation, data: Any) -> Any:
     command's manifest ``readback``/``no_readback`` declaration -- see
     :mod:`mammoth_cli.runtime.state`).
     """
+    from mammoth_cli.runtime.state import with_state
+    from mammoth_cli.runtime.verify import with_verify
+
     record = command_by_id(invocation.command_id) or {}
     if record.get("mutation_class") == "read" or not record.get("sdk_symbol"):
         return data
@@ -943,6 +988,32 @@ def _dry_run(handler: Handler, invocation: Invocation) -> tuple[Any, dict[str, A
         return report, {"profile": invocation.profile, "project_id": resolved_project(invocation)}
 
 
+def live_command_summary(command_id: str) -> str | None:
+    """The backing handler's docstring first line, the lead of a command's help.
+
+    Reading it imports the handler's module, so a group listing takes it from
+    the generated index (:func:`_indexed_summary`) instead.
+    """
+    handler = HANDLERS.get(command_id) or BESPOKE.get(command_id)
+    doc = inspect.getdoc(handler) if handler is not None else None
+    if not doc:
+        return None
+    # First non-empty line, with RST inline-code backticks flattened to plain
+    # quotes so the help reads as prose rather than reStructuredText.
+    return doc.strip().splitlines()[0].strip().replace("``", "'") or None
+
+
+@cache
+def _summary_index() -> dict[str, str]:
+    """Every command's help summary, generated by ``scripts/gen_help_summaries.py``."""
+    path = Path(__file__).parent / "commands" / "help_summaries.json"
+    return cast(dict[str, str], json.loads(path.read_text(encoding="utf-8")))
+
+
+def _indexed_summary(command_id: str) -> str | None:
+    return _summary_index().get(command_id)
+
+
 def _command_help(command_id: str, record: dict[str, Any] | None) -> str | None:
     """Build a command's user-facing ``--help`` summary.
 
@@ -955,15 +1026,12 @@ def _command_help(command_id: str, record: dict[str, Any] | None) -> str | None:
     every required positional and ``--input`` field. ``known_restrictions``
     remains available to machines through ``schema get``.
     """
+    from mammoth_cli.commands.schema import IN_PLACE_RECIPE, edits_view_in_place
+
     parts: list[str] = []
-    handler = HANDLERS.get(command_id) or BESPOKE.get(command_id)
-    doc = inspect.getdoc(handler) if handler is not None else None
-    if doc:
-        # First non-empty line, with RST inline-code backticks flattened to plain
-        # quotes so the help reads as prose rather than reStructuredText.
-        summary = doc.strip().splitlines()[0].strip().replace("``", "'")
-        if summary:
-            parts.append(summary)
+    summary = live_command_summary(command_id)
+    if summary:
+        parts.append(summary)
     if record is not None and edits_view_in_place(record):
         parts.append(IN_PLACE_RECIPE)
     example = (record or {}).get("agent_example")
@@ -1032,6 +1100,15 @@ def _command_tree() -> tuple[dict[tuple[str, ...], str], frozenset[tuple[str, ..
     return path_to_command, frozenset(prefixes & path_to_command.keys())
 
 
+def _leaf_context_settings(command_id: str) -> dict[str, bool]:
+    """Click settings for one command: a bespoke command declares every option it
+    accepts, so Click itself rejects an unknown one; a generic leaf collects its
+    trailing tokens and validates them in :func:`validate_extra_args`."""
+    if command_id in BESPOKE:
+        return {}
+    return {"allow_extra_args": True, "ignore_unknown_options": True}
+
+
 def _group_typer(tokens: tuple[str, ...], command_id: str | None) -> typer.Typer:
     if command_id is not None:
         # This node is both a group and an invocable command.
@@ -1050,6 +1127,86 @@ def _group_typer(tokens: tuple[str, ...], command_id: str | None) -> typer.Typer
     )
 
 
+def _lazy_help_command(command_id: str) -> type[TyperCommand]:
+    """A command class whose help is read from the handler only when printed.
+
+    Building a group registers every command in it; reading each help text up
+    front imports every handler module of the group, though a run uses one.
+    """
+
+    class LazyHelpCommand(TyperCommand):
+        @property
+        def help(self) -> str | None:
+            return _command_help(command_id, command_by_id(command_id))
+
+        @help.setter
+        def help(self, value: str | None) -> None:
+            """Ignore the registration-time placeholder; the handler is the source."""
+
+        @property
+        def short_help(self) -> str | None:
+            """The group listing prints only the first paragraph, which is the summary."""
+            return _indexed_summary(command_id)
+
+        @short_help.setter
+        def short_help(self, value: str | None) -> None:
+            """Ignore the registration-time value; the handler is the source."""
+
+    return LazyHelpCommand
+
+
+def _unbuilt_leaf() -> None:
+    """Registration placeholder: a lazy leaf takes its real callback from the built command."""
+
+
+def _lazy_leaf_command(command_id: str) -> type[TyperCommand]:
+    """A generic leaf whose parameters and callback are built when first read.
+
+    Building a leaf derives its positionals from the SDK signature, which
+    imports the SDK model modules. A group's ``--help`` lists names and help
+    only, so it never reads them; a run reads them for the one command used.
+    """
+
+    class LazyLeafCommand(_lazy_help_command(command_id)):  # type: ignore[misc]
+        _built: _ClickCommand | None = None
+
+        def _real(self) -> _ClickCommand:
+            if self._built is None:
+                from typer.models import CommandInfo
+
+                info = CommandInfo(
+                    name=self.name,
+                    callback=_build_leaf(command_id),
+                    help=_command_help(command_id, command_by_id(command_id)),
+                    rich_help_panel=self.rich_help_panel,
+                    context_settings=_leaf_context_settings(command_id),
+                )
+                self._built = typer.main.get_command_from_info(
+                    info,
+                    pretty_exceptions_short=_LAZY_SETTINGS["pretty_exceptions_short"],
+                    rich_markup_mode=self.rich_markup_mode,
+                )
+            return self._built
+
+        @property
+        def params(self) -> list[_ClickParameter]:
+            return self._real().params
+
+        @params.setter
+        def params(self, value: list[_ClickParameter]) -> None:
+            """Ignore the registration-time parameters; the built command owns them."""
+
+        @property
+        def callback(self) -> Any:
+            return self._real().callback
+
+        @callback.setter
+        def callback(self, value: Any) -> None:
+            """Ignore the registration-time placeholder callback."""
+
+    return LazyLeafCommand
+
+
 def _populate(base: tuple[str, ...], group: typer.Typer) -> None:
     """Register every command below ``base`` (exclusive) on ``group``."""
     path_to_command, containers = _command_tree()
@@ -1082,14 +1239,14 @@ def _populate(base: tuple[str, ...], group: typer.Typer) -> None:
     for tokens, command_id in sorted(below.items()):
         if tokens in containers:
             continue
-        record = command_by_id(command_id)
-        callback = BESPOKE.get(command_id) or _build_leaf(command_id)
+        bespoke = BESPOKE.get(command_id)
         _group_for(tokens[:-1]).command(
             name=tokens[-1],
-            help=_command_help(command_id, record),
+            cls=_lazy_help_command(command_id) if bespoke else _lazy_leaf_command(command_id),
+            help="",
             rich_help_panel=_ROOT_HELP_PANELS.get(tokens[0]) if len(tokens) == 1 else None,
-            context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
-        )(callback)
+            context_settings=_leaf_context_settings(command_id),
+        )(bespoke or _unbuilt_leaf)
 
 
 @cache
@@ -1121,6 +1278,77 @@ def _load_top_level_group(name: str) -> Any:
     return typer.main.get_group_from_info(info, **_LAZY_SETTINGS)
 
 
+# Root ``--help`` prints each top-level leaf's help; reading it from the handler
+# would import the handler's module (and its SDK dependencies). A test pins this
+# table to :func:`_command_help` so it cannot drift.
+_ROOT_LEAF_HELP: dict[str, str] = {
+    "calc": (
+        "Evaluate one arithmetic expression exactly."
+        "\n\nExample: mammoth calc '2063664 - 1917815'"
+    ),
+    "doctor": (
+        "Run environment and connectivity diagnostics."
+        "\n\nExample: mammoth doctor\n\nInput fields: wait (int)"
+    ),
+    "link": (
+        "Read the workspace, project, folder, dataset and view ids out of a pasted app URL."
+        "\n\nExample: mammoth link https://app.mammoth.io/workspaces/1/projects/2/data/datasets"
+    ),
+    "resolve": (
+        "Say what NAME refers to: a dataset, a view or a project, with ids and projects."
+        "\n\nExample: mammoth resolve uqa-w29-ren"
+    ),
+    "upgrade": (
+        "Upgrade the mammoth CLI to the latest (or a specified) version from PyPI."
+        "\n\nExample: mammoth upgrade"
+    ),
+    "version": "Example: mammoth version",
+}
+_LAZY_LEAF_IDS: dict[str, str] = {}
+
+
+def _load_root_leaf(name: str) -> Any:
+    from typer.models import CommandInfo
+
+    command_id = _LAZY_LEAF_IDS[name]
+    info = CommandInfo(
+        name=name,
+        callback=BESPOKE.get(command_id) or _build_leaf(command_id),
+        help=_command_help(command_id, command_by_id(command_id)),
+        rich_help_panel=_ROOT_HELP_PANELS.get(name),
+        context_settings=_leaf_context_settings(command_id),
+    )
+    return typer.main.get_command_from_info(
+        info,
+        pretty_exceptions_short=_LAZY_SETTINGS["pretty_exceptions_short"],
+        rich_markup_mode=_LAZY_SETTINGS["rich_markup_mode"],
+    )
+
+
+def _root_leaf_stub(name: str) -> Any:
+    """A placeholder leaf carrying only what the root ``--help`` listing prints."""
+    return TyperCommand(
+        name=name,
+        help=_ROOT_LEAF_HELP[name],
+        rich_help_panel=_ROOT_HELP_PANELS.get(name),
+        rich_markup_mode=_LAZY_SETTINGS["rich_markup_mode"],
+    )
+
+
+def _load_lazy_root(name: str) -> Any:
+    return _load_root_leaf(name) if name in _LAZY_LEAF_IDS else _load_top_level_group(name)
+
+
+def _group_stub(name: str) -> Any:
+    """A placeholder group carrying only what the root ``--help`` listing prints."""
+    return TyperGroup(
+        name=name,
+        help=_GROUP_DESCRIPTIONS.get(name, f"Commands for {name}."),
+        rich_help_panel=_ROOT_HELP_PANELS.get(name),
+        rich_markup_mode=_LAZY_SETTINGS["rich_markup_mode"],
+    )
+
+
 def build_app() -> typer.Typer:
     """Construct the Typer command tree from the command manifests.
 
@@ -1155,13 +1383,8 @@ def build_app() -> typer.Typer:
         if (name,) in containers or (name,) not in path_to_command:
             lazy.append(name)
             continue
-        command_id = path_to_command[(name,)]
-        root.command(
-            name=name,
-            help=_command_help(command_id, command_by_id(command_id)),
-            rich_help_panel=_ROOT_HELP_PANELS.get(name),
-            context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
-        )(BESPOKE.get(command_id) or _build_leaf(command_id))
+        _LAZY_LEAF_IDS[name] = path_to_command[(name,)]
+        lazy.append(name)
     _LAZY_GROUP_NAMES[:] = lazy
     _LAZY_SETTINGS.update(
         pretty_exceptions_short=root.pretty_exceptions_short,
@@ -1196,6 +1419,9 @@ def registered_command_paths() -> set[str]:
 
     walk(app, ())
     for name in _LAZY_GROUP_NAMES:
+        if name in _LAZY_LEAF_IDS:
+            paths.add(name)
+            continue
         sub = _top_level_typer(name)
         if sub.registered_callback is not None:
             paths.add(name)

{mammoth_cli-2.2.53 → mammoth_cli-2.2.55}/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 660; 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 663; 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:
 
@@ -50,8 +50,8 @@ Load only the applicable domain file:
 - [upgrade](commands/upgrade.md) — 1 published commands
 - [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) — 97 published commands
+- [view-transform](commands/view-transform.md) — 34 published commands
+- [view](commands/view.md) — 98 published commands
 - [webhook](commands/webhook.md) — 7 published commands
 - [workflow](commands/workflow.md) — 16 published commands
 - [workspace](commands/workspace.md) — 26 published commands

{mammoth_cli-2.2.53 → mammoth_cli-2.2.55}/mammoth_cli/bundled_skill/mammoth-cli/references/commands/view-transform.md

@@ -142,6 +142,16 @@ Result: `ViewTransformFilterResult`; mutation `reversible_pipeline`, confirmatio
 
 Status on release: ran once on CLI 2.0.40 through `view.task.add` and was read back with `view data get`; other inputs for this transform are untried.
 
+### `view.transform.first-name`
+
+Run: `mammoth view transform first-name`. Exact input fields: `mammoth schema get view.transform.first-name`.
+
+Example: `mammoth view transform first-name 123 --input '{"column": "Name", "new_column": "First name", "dataset_id": 456}'`. Placeholders are illustrative; resolve IDs and input from observed reads.
+
+Result: `ViewTransformFirstNameResult`; mutation `reversible_pipeline`, confirmation `none`, wait policy `always_wait`.
+
+Status on release: untried; it submits through `view.task.add`, but this transform was not among those run.
+
 ### `view.transform.generate-sql`
 
 Run: `mammoth view transform generate-sql`. Exact input fields: `mammoth schema get view.transform.generate-sql`.
@@ -312,6 +322,16 @@ Result: `ViewTransformUnnestResult`; mutation `reversible_pipeline`, confirmatio
 
 Status on release: ran once on CLI 2.0.40 through `view.task.add` and was read back with `view data get`; other inputs for this transform are untried.
 
+### `view.transform.update-column`
+
+Run: `mammoth view transform update-column`. Exact input fields: `mammoth schema get view.transform.update-column`.
+
+Example: `mammoth view transform update-column 123 --input '{"column": "Cost", "expression": "Cost + 5", "dataset_id": 456}'`. Placeholders are illustrative; resolve IDs and input from observed reads.
+
+Result: `ViewTransformUpdateColumnResult`; mutation `reversible_pipeline`, confirmation `none`, wait policy `always_wait`.
+
+Status on release: untried; it submits through `view.task.add`, but this transform was not among those run.
+
 ### `view.transform.window`
 
 Run: `mammoth view transform window`. Exact input fields: `mammoth schema get view.transform.window`.

{mammoth_cli-2.2.53 → mammoth_cli-2.2.55}/mammoth_cli/bundled_skill/mammoth-cli/references/commands/view.md

@@ -312,6 +312,8 @@ Result: `ViewDerivativeCreateResult`; mutation `benign_mutation`, confirmation `
 
 Status on release: ran once on CLI 2.0.24 — payload probe 2026-09-19: exit 0 on release with CLI 2.0.24. Created derivative id=6 on view 123 (project 52, dataset 104) with the column INTERNAL name as ARGUMENT; metric_status DONE on read-back. The same call with the display name reproduces the HTTP 500…
 
+A METRIC shows as an explore-panel card via `display_properties`; the CLI defaults it to the metric card, and the result's `card` says whether one exists.
+
 ### `view.derivative.data`
 
 Run: `mammoth view derivative data`. Exact input fields: `mammoth schema get view.derivative.data`.
@@ -426,7 +428,7 @@ Status on release: untried; no live run recorded.
 
 Run: `mammoth view explore-panel set`. Exact input fields: `mammoth schema get view.explore-panel.set`.
 
-Example: `mammoth view explore-panel set 123 --input '{"panel": {"open": true, "items": [{"column": "column_1", "renderType": "chart"}]}}'`. Placeholders are illustrative; resolve IDs and input from observed reads.
+Example: `mammoth view explore-panel set 123 --input '{"panel": {"columns": "all"}}'`. Placeholders are illustrative; resolve IDs and input from observed reads.
 
 Result: `ViewExplorePanelSetResult`; mutation `benign_mutation`, confirmation `none`, wait policy `not_async`.
 
@@ -548,6 +550,16 @@ Result: `ViewExportListResult`; mutation `read`, confirmation `none`, wait polic
 
 Status on release: ran once on CLI 2.0.28 — ILG simulation 2026-09-19: exit 0 on release with CLI 2.0.28. Listed both internal_dataset exports with target_properties (DS_NAME, COLUMN_MAPPING, project fields). Single invocation only.
 
+### `view.export.live-link`
+
+Run: `mammoth view export live-link`. Exact input fields: `mammoth schema get view.export.live-link`.
+
+Example: `mammoth view export live-link 123 123 --input '{"file_name": "report_share.csv"}'`. Illustrative only: append `--yes` after observing an owned target.
+
+Result: `ViewExportLiveLinkResult`; mutation `external_effect`, confirmation `yes_always`, wait policy `always_wait`.
+
+Status on release: untried; no live run recorded.
+
 ### `view.export.managed-s3`
 
 Run: `mammoth view export managed-s3`. Exact input fields: `mammoth schema get view.export.managed-s3`.

{mammoth_cli-2.2.53 → mammoth_cli-2.2.55}/mammoth_cli/bundled_skill/mammoth-cli/references/recipes/exports.md

@@ -29,6 +29,20 @@ If `schema get view.export.csv` rejects requested fields, preserve the
 structured error and discover another declared export route rather than using
 raw HTTP.
 
+## Share a view as a live link
+
+```bash
+mammoth view export live-link VIEW_ID DATASET_ID --project PROJECT_ID --yes
+# -> {"url": "<the live link>"}
+```
+
+An S3 export flagged `liveLink`: a public URL that serves the view's data and
+stays current as the view's pipeline re-runs. Optional `--input` fields are
+`file_name` (`<prefix>_<token>.csv`; the server replaces the token), `file_type`
+(`csv`, `json`, `parquet`) and `include_hidden`. A plan without live links is
+refused by the backend; its message comes back as the error. Hand the URL to the
+user as returned; anyone holding it can read the data.
+
 ## Send a view into another project (parallel send, branch-out)
 
 `view export dataset` writes the view's rows into a Mammoth dataset **as a

mammoth_cli-2.2.55/mammoth_cli/commands/__init__.py

@@ -0,0 +1,31 @@
+"""commands layer for the Mammoth CLI.
+
+Assembles :data:`BESPOKE`: fully-typed Typer command callbacks that override
+the generic manifest leaf for the command ids they implement. ``app.py``
+imports this module and swaps in a bespoke callback wherever one exists,
+registering it at the exact same manifest path and name as the generic leaf
+it replaces.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from mammoth_cli.commands._lazy import LazyTable
+
+_TARGETS: dict[str, str] = {
+    "auth.login": "mammoth_cli.commands.auth:auth_login",
+    "auth.status": "mammoth_cli.commands.auth:auth_status",
+    "auth.logout": "mammoth_cli.commands.auth:auth_logout",
+    "config.get": "mammoth_cli.commands.config:config_get",
+    "config.set": "mammoth_cli.commands.config:config_set",
+    "config.list": "mammoth_cli.commands.config:config_list",
+    "config.path": "mammoth_cli.commands.config:config_path",
+    "context.project.status": "mammoth_cli.commands.context:context_project_status",
+    "context.project.use": "mammoth_cli.commands.context:context_project_use",
+    "context.project.clear": "mammoth_cli.commands.context:context_project_clear",
+    "upgrade": "mammoth_cli.commands.upgrade:upgrade_command",
+}
+
+#: Command id -> bespoke Typer callback, imported from its module on first use.
+BESPOKE: LazyTable[Callable[..., None]] = LazyTable(_TARGETS)