mammoth-cli 2.2.99__tar.gz → 2.2.100__tar.gz

{mammoth_cli-2.2.99 → mammoth_cli-2.2.100}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.2.99
+Version: 2.2.100
 Summary: Command-line interface for the Mammoth Analytics platform
 Project-URL: homepage, https://mammoth.io
 Project-URL: repository, https://github.com/EdgeMetric/mammothsdk
@@ -19,7 +19,7 @@ Requires-Python: <3.15,>=3.12
 Requires-Dist: certifi>=2026.10.19
 Requires-Dist: jsonschema>=4.20
 Requires-Dist: keyring<26,>=25.7
-Requires-Dist: mammoth-io<0.9,>=0.8.50
+Requires-Dist: mammoth-io<0.9,>=0.8.51
 Requires-Dist: platformdirs<5,>=4.10
 Requires-Dist: pydantic<3,>=2.12.5
 Requires-Dist: pyyaml<7,>=6

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

{mammoth_cli-2.2.99 → mammoth_cli-2.2.100}/mammoth_cli/app.py

@@ -1201,7 +1201,7 @@ def _execute(invocation: Invocation) -> None:
     # 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.compact import COMPACT_COMMANDS, FULL_FLAG, with_compact
+    from mammoth_cli.runtime.compact import FULL_FLAG, FULL_FLAG_COMMANDS, with_compact
     from mammoth_cli.runtime.confirm import refuse_mismatched_confirm
     from mammoth_cli.runtime.dataset_health import with_dataset_health
     from mammoth_cli.runtime.intent_only import refuse_hand_crafted_write
@@ -1214,7 +1214,7 @@ def _execute(invocation: Invocation) -> None:
 
     if invocation.profile is None:
         invocation = replace(invocation, profile=profiles.get_selected(), profile_is_default=True)
-    if invocation.command_id in COMPACT_COMMANDS and FULL_FLAG in invocation.extra_args:
+    if invocation.command_id in FULL_FLAG_COMMANDS and FULL_FLAG in invocation.extra_args:
         invocation = replace(
             invocation,
             extra_args=[arg for arg in invocation.extra_args if arg != FULL_FLAG],
@@ -1508,8 +1508,12 @@ def _command_help(command_id: str, record: dict[str, Any] | None) -> str | None:
     nested = nested_choices_help(command_id)
     if nested:
         parts.append(nested)
-    from mammoth_cli.runtime.compact import COMPACT_COMMANDS, FULL_FLAG
+    from mammoth_cli.runtime.compact import COMPACT_COMMANDS, FULL_FLAG, TRIMMED_READ_COMMANDS
 
+    if command_id in TRIMMED_READ_COMMANDS:
+        parts.append(
+            f"The result leaves out detail you rarely need. Pass {FULL_FLAG} for all of it."
+        )
     if command_id in COMPACT_COMMANDS:
         parts.append(
             "The result is compact: ids, checks, verify and a canvas summary. "
@@ -1794,12 +1798,10 @@ def _load_top_level_group(name: str) -> Any:
 # table to :func:`_command_help` so it cannot drift.
 _ROOT_LEAF_HELP: dict[str, str] = {
     "capabilities": (
-        "List what the CLI cannot do yet, and what to do instead."
-        "\n\nExample: mammoth capabilities"
+        "List what the CLI cannot do yet, and what to do instead.\n\nExample: mammoth capabilities"
     ),
     "calc": (
-        "Evaluate one arithmetic expression exactly."
-        "\n\nExample: mammoth calc '2063664 - 1917815'"
+        "Evaluate one arithmetic expression exactly.\n\nExample: mammoth calc '2063664 - 1917815'"
     ),
     "doctor": (
         "Run environment and connectivity diagnostics."

{mammoth_cli-2.2.99 → mammoth_cli-2.2.100}/mammoth_cli/bundled_skill/mammoth-cli/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: mammoth-cli
-version: 2.2.99
+version: 2.2.100
 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."
 ---
 
@@ -92,8 +92,7 @@ mammoth schema find "join two datasets; remove duplicates; build a dashboard"
 | Deliver the rows | `view export csv`, `view export postgres`, `view export dataset` |
 | Run something on a schedule or on new data (refresh, append, alert) | `automation create`: a condition (`at_specific_time`, new file in a folder, ...) and tasks (`run_data_retrieval`, `append_data`, `send_an_alert`, `pull_cloud_files`). `schedule create` only pulls a connector's data. An upload can't refresh; a URL dataset: `dataset refresh` on demand, never on a schedule; say so. Recipe: [recurring work](references/recipes/scheduling.md) |
 
-Call a find result (or `suggestions` entry) from its `accepted_fields` and
-`agent_example`. Before concluding the CLI cannot do something the web app
+Call a find result from its `agent_example` and `accepted_fields`. Before concluding the CLI cannot do something the web app
 does, run `mammoth capabilities` (known gaps) and check
 `view transform --help` and "View settings, and what has no
 command" in [about Mammoth](references/about-mammoth.md). Do not switch to
@@ -142,7 +141,7 @@ your report. If no column links the files, ask before you combine them.
 - Ids are positionals; request fields are one `--input '{...}'` document;
   no per-field flags (`project create NAME`, not `--name`).
 - `COMMAND --help` lists input fields and allowed values; `schema find WORDS` inlines
-  `accepted_fields`/`agent_example` for top matches, else `schema get
+  `accepted_fields`/`agent_example` for top matches (`--full`: all), else `schema get
   ID,ID` (one call; `--input '{"full": true}'` for all
   fields); `schema list`/`schema list view` list families.
 - Uploads return a **dataset** id; transforms, joins, exports and previews

{mammoth_cli-2.2.99 → mammoth_cli-2.2.100}/mammoth_cli/commands/doctor.py

@@ -18,9 +18,13 @@ from pathlib import Path
 from typing import Any, cast
 from urllib.parse import urlsplit
 
+from mammoth.client import server_health
+from mammoth.exceptions import MammothAPIError
+
 from mammoth_cli import __version__
 from mammoth_cli.context import credentials, profiles
-from mammoth_cli.context.resolver import ResolvedAuth, resolve_auth
+from mammoth_cli.context.endpoint import resolve_base_url
+from mammoth_cli.context.resolver import SERVER_PREFIX_ENV, ResolvedAuth, resolve_auth
 from mammoth_cli.errors.envelope import CliError
 from mammoth_cli.runtime import embedded, runlog, updates
 from mammoth_cli.runtime.invocation import Invocation
@@ -41,6 +45,34 @@ def _check(name: str, ok: bool, detail: str) -> dict[str, Any]:
     return {"name": name, "ok": ok, "detail": detail}
 
 
+_SERVER_TIMEOUT_SECONDS = 10.0
+
+
+def _server_base_url(profile_name: str, resolved: str | None) -> str:
+    """The API base url to probe: the resolved one, else from env or profile, no login needed."""
+    if resolved is not None:
+        return resolved
+    prefix = os.environ.get(SERVER_PREFIX_ENV, "").strip() or None
+    if prefix is None:
+        record = profiles.get_profile(profile_name)
+        prefix = record.server_prefix if record is not None else None
+    return resolve_base_url(prefix)
+
+
+def _check_server(base_url: str, timeout: float = _SERVER_TIMEOUT_SECONDS) -> dict[str, Any]:
+    """Probe the public ``/health`` route (no credentials) and report status and latency."""
+    try:
+        health = server_health(base_url, timeout)
+    except MammothAPIError as error:
+        return _check("server", False, str(error))
+    status = health["status_code"]
+    ok = 200 <= status < 300
+    detail = (
+        f"healthy in {health['latency_ms']} ms" if ok else f"HTTP {status} from {base_url}/health"
+    )
+    return {**_check("server", ok, detail), **health}
+
+
 def _check_not_applicable(name: str) -> dict[str, Any]:
     """A check that has no meaning in an embedded call; it never fails doctor."""
     return {
@@ -326,6 +358,13 @@ def doctor(invocation: Invocation) -> HandlerResult:
         endpoint_detail = error.code
         auth_error_code = error.code
     checks.append(_check("endpoint", auth_ok, endpoint_detail))
+    try:
+        server_check = _check_server(
+            _server_base_url(profile_name, endpoint_detail if auth_ok else None)
+        )
+    except CliError as error:
+        server_check = _check("server", False, f"no server to probe: {error.code}")
+    checks.append(server_check)
 
     connection_ok = False
     connection_detail = "not attempted"

{mammoth_cli-2.2.99 → mammoth_cli-2.2.100}/mammoth_cli/commands/registry.py

@@ -205,11 +205,19 @@ def _cap_inline_detail(result: dict[str, Any], keep: int) -> None:
             entry.pop("agent_example", None)
 
 
+def _find_output(result: dict[str, Any], invocation: Invocation) -> dict[str, Any]:
+    """*result* cut to what picks and calls a command, unless ``--full``."""
+    from mammoth_cli.commands import schema as schema_cmd
+
+    return result if invocation.full_output else schema_cmd.trim_find_result(result)
+
+
 def _schema_find(invocation: Invocation) -> HandlerResult:
     from mammoth_cli.commands import schema as schema_cmd
+    from mammoth_cli.runtime.compact import FULL_FLAG
     from mammoth_cli.runtime.strict import COMMAND_FLAGS
 
-    flags = COMMAND_FLAGS["schema.find"]
+    flags = COMMAND_FLAGS["schema.find"] - {FULL_FLAG}
     words = [str(invocation.bound_input().get("query") or ""), *map(str, invocation.extra_args)]
     if any(word in flags for word in words):
         # 'schema find --unsupported [WORDS]': what the CLI cannot do yet.
@@ -221,7 +229,7 @@ def _schema_find(invocation: Invocation) -> HandlerResult:
     if not query.strip():
         raise _EMPTY_QUERY_ERROR
     if ";" not in query:
-        return schema_cmd.find_schemas(query), {}
+        return _find_output(schema_cmd.find_schemas(query), invocation), {}
     # Several goals in one call ("join customers onto orders; remove
     # duplicate rows; build a dashboard"): run the existing single-goal
     # search per goal instead of round-tripping once per goal.
@@ -245,6 +253,7 @@ def _schema_find(invocation: Invocation) -> HandlerResult:
         # several candidates.
         for result in results:
             _cap_inline_detail(result, 1)
+    results = [_find_output(result, invocation) for result in results]
     return {
         "goals": [{"goal": goal, **result} for goal, result in zip(goals, results, strict=True)]
     }, {}

{mammoth_cli-2.2.99 → mammoth_cli-2.2.100}/mammoth_cli/commands/schema.py

@@ -530,8 +530,7 @@ _COMMAND_DISCOVERY_PURPOSES = {
     # complete periods and gives a range. Generic words (will, estimate, next,
     # month) are left out: each would make other goals need this text to match.
     "view.data.forecast": (
-        "forecast forecasts forecasting projection projections projected predict prediction "
-        "future"
+        "forecast forecasts forecasting projection projections projected predict prediction future"
     ),
     # What a term means for one dataset (gap proposal P13): said once, used by
     # every chat on it. "remember that churned means" is a definition, not a
@@ -1193,6 +1192,10 @@ _NO_MATCH_HINT_WITH_SUGGESTIONS = (
     "No single command matched every word, but 'suggestions' lists the closest candidates "
     "-- each with its own matched_terms. Try one of those before rephrasing."
 )
+_NO_MATCH_HINT_PARTIAL = (
+    "No single command matched every word; 'matches' lists the closest candidates "
+    "(partial: true) -- each with its own matched_terms. Try one of those before rephrasing."
+)
 _NO_MATCH_HINT_NO_SUGGESTIONS = (
     "No command matched any word; try fewer or other words. 'mammoth view transform --help' "
     "lists every data transformation (join, pivot, filter, dedupe, math, ...), and 'mammoth "
@@ -2215,7 +2218,9 @@ def _schema_common(record: dict[str, Any]) -> dict[str, Any]:
     contract_level = (
         "opaque_expert"
         if record["command_id"] in _OPAQUE_EXPERT_COMMANDS
-        else "partially_typed" if opaque_fields else "typed"
+        else "partially_typed"
+        if opaque_fields
+        else "typed"
     )
     return {
         "server_status": record.get("server_status", "served"),
@@ -2612,6 +2617,50 @@ def find_schemas(
     return result
 
 
+#: Keys of an inlined accepted field that a caller needs to fill it in; its
+#: nested JSON Schema is what ``schema get`` is for.
+_FIND_FIELD_KEYS = ("name", "type", "required", "enum")
+#: Entry keys a find leaves out unless ``--full``: ``schema get`` has them.
+_FIND_DROPPED_KEYS = ("full_schema_command", "known_restrictions", "matched_on")
+
+
+def _trim_find_entry(entry: dict[str, Any]) -> dict[str, Any]:
+    """One match cut to what picks and calls it: id, summary, safety class, example.
+
+    The command id is the key ``schema get`` takes for the rest.
+    """
+    from mammoth_cli.app import _indexed_summary
+
+    trimmed = {key: value for key, value in entry.items() if key not in _FIND_DROPPED_KEYS}
+    summary = _indexed_summary(entry["command_id"])
+    if summary:
+        trimmed["summary"] = summary
+    if trimmed.get("server_status") == "served":
+        del trimmed["server_status"]
+    if "accepted_fields" in trimmed:
+        trimmed["accepted_fields"] = [
+            {key: field[key] for key in _FIND_FIELD_KEYS if field.get(key) is not None}
+            for field in trimmed["accepted_fields"]
+        ]
+    return trimmed
+
+
+def trim_find_result(result: dict[str, Any]) -> dict[str, Any]:
+    """The default ``schema find`` shape: trimmed entries, near misses listed once.
+
+    ``suggestions`` repeated the partial ``matches`` entry for entry, so only
+    ``matches`` stays. ``--full`` returns the whole shape.
+    """
+    trimmed = dict(result)
+    trimmed["matches"] = [_trim_find_entry(entry) for entry in result["matches"]]
+    if "suggestions" in trimmed:
+        del trimmed["suggestions"]
+        trimmed["hint"] = (
+            _NO_MATCH_HINT_PARTIAL if trimmed["matches"] else _NO_MATCH_HINT_NO_SUGGESTIONS
+        )
+    return trimmed
+
+
 def _browse(entries: list[dict[str, Any]]) -> dict[str, Any]:
     """The families behind *entries* and how to list each one in full: a keyword
     find surfaces one way to do a thing, its family holds the siblings."""

{mammoth_cli-2.2.99 → mammoth_cli-2.2.100}/mammoth_cli/runtime/compact.py

@@ -32,6 +32,12 @@ COMPACT_COMMANDS = frozenset(
     }
 )
 
+#: Reads trimmed by default; ``--full`` returns the old shape. ``schema find`` cuts
+#: each match to what picks and calls it; ``canvas get`` leaves out null and empty fields.
+TRIMMED_READ_COMMANDS = frozenset({"schema.find", "dashboard.canvas.get"})
+#: Every command that takes ``--full``.
+FULL_FLAG_COMMANDS = COMPACT_COMMANDS | TRIMMED_READ_COMMANDS
+
 #: Keys left out in compact mode: the planner's working state, not a result.
 _OMITTED_KEYS = ("plan", "specs")
 #: Keys kept exactly as they are, nulls included.
@@ -87,6 +93,27 @@ def _null_only(original: Any, compacted: Any) -> bool:
     return isinstance(original, dict) and bool(original) and compacted == {}
 
 
+def _drop_nulls(value: Any) -> Any:
+    """*value* without null fields at any depth, and without dicts that held only nulls.
+
+    An explicit ``[]``, ``{}`` or ``""`` stays: ``canvas save`` treats an absent or
+    null overlay as "keep the head's" and an explicit empty one as "clear it".
+    List items keep their place.
+    """
+    if isinstance(value, list):
+        return [_drop_nulls(item) for item in value]
+    if not isinstance(value, dict):
+        return value
+    result: dict[str, Any] = {}
+    for key, item in value.items():
+        if item is None:
+            continue
+        pruned = _drop_nulls(item)
+        if not _null_only(item, pruned):
+            result[key] = pruned
+    return result
+
+
 def _dashboard_id(invocation: Invocation, data: dict[str, Any]) -> Any:
     for value in (invocation.positionals.get("dashboard_id"), data.get("dashboard_id")):
         if isinstance(value, (int, str)) and str(value):
@@ -96,6 +123,8 @@ def _dashboard_id(invocation: Invocation, data: dict[str, Any]) -> Any:
 
 def with_compact(invocation: Invocation, data: Any) -> Any:
     """``data`` compacted for a command in :data:`COMPACT_COMMANDS`, unless ``--full``."""
+    if invocation.command_id == "dashboard.canvas.get":
+        return data if invocation.full_output else _drop_nulls(data)
     if (
         invocation.command_id not in COMPACT_COMMANDS
         or invocation.full_output

{mammoth_cli-2.2.99 → mammoth_cli-2.2.100}/mammoth_cli/runtime/strict.py

@@ -38,7 +38,7 @@ from collections.abc import Iterable, Mapping
 from typing import Any
 
 from mammoth_cli.errors.envelope import EXIT_USAGE, CliError
-from mammoth_cli.runtime.compact import COMPACT_COMMANDS, FULL_FLAG
+from mammoth_cli.runtime.compact import FULL_FLAG, FULL_FLAG_COMMANDS
 from mammoth_cli.runtime.reveal import REVEAL_COMMANDS, REVEAL_FLAG
 from mammoth_cli.services.argspec import FieldSpec
 from mammoth_cli.services.command_contract import (
@@ -57,11 +57,11 @@ NEGATIVE_NUMBER = re.compile(r"^-(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$")
 #: Flags a few commands take in place of the ``--input`` field of the same name.
 COMMAND_FLAGS: dict[str, frozenset[str]] = {
     "schema.get": frozenset({"--full"}),
-    "schema.find": frozenset({"--unsupported"}),
     # Keep going after a failed line instead of stopping at the first.
     "run": frozenset({"--continue"}),
     # The compacted dashboard writes: --full returns the whole response.
-    **{command_id: frozenset({FULL_FLAG}) for command_id in COMPACT_COMMANDS},
+    **{command_id: frozenset({FULL_FLAG}) for command_id in FULL_FLAG_COMMANDS},
+    "schema.find": frozenset({"--unsupported", FULL_FLAG}),
     # A once-shown credential is masked unless --reveal asks for it.
     **{command_id: frozenset({REVEAL_FLAG}) for command_id in REVEAL_COMMANDS},
 }
@@ -393,7 +393,7 @@ def _unknown_field_hint(command_id: str, document: dict[str, Any], accepted: lis
             f"mammoth {command_id.replace('.', ' ')} ... --project {document['project_id']} "
             "(or omit it to use the active project)."
         )
-    return f"Accepted fields: {', '.join(accepted) or '(none)' }."
+    return f"Accepted fields: {', '.join(accepted) or '(none)'}."
 
 
 def _sort_entry(entry: Any) -> Any:

{mammoth_cli-2.2.99 → mammoth_cli-2.2.100}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "mammoth-cli"
-version = "2.2.99"
+version = "2.2.100"
 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.50,<0.9)",
+    "mammoth-io (>=0.8.51,<0.9)",
     "typer (>=0.27,<0.28)",
     "rich (>=15,<16)",
     "platformdirs (>=4.10,<5)",