mammoth-cli 2.0.30__tar.gz → 2.0.31__tar.gz

{mammoth_cli-2.0.30 → mammoth_cli-2.0.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.0.30
+Version: 2.0.31
 Summary: Command-line interface for the Mammoth Analytics platform
 Project-URL: homepage, https://mammoth.io
 Project-URL: repository, https://github.com/EdgeMetric/mammothsdk

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

{mammoth_cli-2.0.30 → mammoth_cli-2.0.31}/mammoth_cli/app.py

@@ -330,6 +330,13 @@ class _LeafGroup(TyperGroup):
 class _EnvelopeGroup(TyperGroup):
     """Root group that renders Click usage errors as the machine error envelope.
 
+    It also materialises top-level command groups lazily (see
+    :func:`_load_top_level_group`): ``list_commands`` and ``get_command`` know
+    every group by name from the manifest, but a group's Click tree is only
+    built when it is invoked, completed or listed in ``--help``. Reading
+    ``commands`` directly materialises them all, so tools that walk the tree
+    still see the full surface.
+
     Click's standalone error handling prints a human ``Usage: ... Error: ...``
     message and exits, even under ``--output json``: an agent driving the CLI
     then receives un-parseable prose (or, for a leaf that also parents
@@ -345,6 +352,28 @@ class _EnvelopeGroup(TyperGroup):
     on.
     """
 
+    @property  # type: ignore[override]
+    def commands(self) -> dict[str, Any]:
+        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)
+        return loaded
+
+    @commands.setter
+    def commands(self, value: Any) -> None:
+        self.__dict__["_eager_commands"] = dict(value or {})
+
+    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)]
+
+    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)
+        return eager.get(cmd_name)
+
     def main(self, *args: Any, **kwargs: Any) -> Any:
         if not kwargs.get("standalone_mode", True):
             return super().main(*args, **kwargs)
@@ -888,68 +917,55 @@ def _short_type(type_name: str) -> str:
     return " | ".join(part.strip().rsplit(".", 1)[-1] for part in text.split("|"))[:40]
 
 
-def build_app() -> typer.Typer:
-    """Construct the full Typer command tree from the command manifests."""
-    root = typer.Typer(
-        name="mammoth",
-        help=(
-            "Command-line interface for the Mammoth Analytics platform.\n\n"
-            "Start with 'mammoth doctor' to check access, 'mammoth schema find QUERY' "
-            "to locate a command, and 'mammoth schema get COMMAND_ID' for its full input schema."
-        ),
+def _command_records() -> list[dict[str, Any]]:
+    return [r for r in load_commands() if r.get("disposition") != "alias"]
+
+
+@cache
+def _command_tree() -> tuple[dict[tuple[str, ...], str], frozenset[tuple[str, ...]]]:
+    """Map every command path to its id, and name the container nodes.
+
+    A "container command" sits at a node that also has deeper subcommands
+    (e.g. ``dataset file-settings``, which also has ``... undo`` / ``... update``).
+    """
+    path_to_command = {
+        tuple(r["command_path"].split()): r["command_id"] for r in _command_records()
+    }
+    prefixes: set[tuple[str, ...]] = set()
+    for tokens in path_to_command:
+        for depth in range(1, len(tokens)):
+            prefixes.add(tokens[:depth])
+    return path_to_command, frozenset(prefixes & path_to_command.keys())
+
+
+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.
+        sub = typer.Typer(
+            cls=_LeafGroup,
+            no_args_is_help=False,
+            invoke_without_command=True,
+            context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+        )
+        sub.callback()(_build_leaf(command_id, is_group_callback=True))
+        return sub
+    return typer.Typer(
+        help=_GROUP_DESCRIPTIONS.get(tokens[0], f"Commands for {' '.join(tokens)}."),
         no_args_is_help=True,
-        add_completion=True,
-        cls=_EnvelopeGroup,
         context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
     )
 
-    @root.callback()
-    def _root(
-        version: bool = typer.Option(
-            False, "--version", callback=_version_callback, is_eager=True, help="Show version."
-        ),
-    ) -> None:
-        """Root callback holding eager global options."""
 
-    records = [r for r in load_commands() if r.get("disposition") != "alias"]
-    path_to_command: dict[tuple[str, ...], str] = {
-        tuple(r["command_path"].split()): r["command_id"] for r in records
-    }
-    all_paths = set(path_to_command)
-    # A "container command" sits at a node that also has deeper subcommands
-    # (e.g. `dataset file-settings`, which also has `... undo` / `... update`).
-    containers = {
-        tokens
-        for tokens in all_paths
-        if any(other != tokens and other[: len(tokens)] == tokens for other in all_paths)
-    }
-
-    groups: dict[tuple[str, ...], typer.Typer] = {(): root}
-
-    def _make_group(tokens: tuple[str, ...]) -> typer.Typer:
-        command_id = path_to_command.get(tokens)
-        if command_id is not None:
-            # This node is both a group and an invocable command.
-            sub = typer.Typer(
-                cls=_LeafGroup,
-                no_args_is_help=False,
-                invoke_without_command=True,
-                context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
-            )
-            sub.callback()(_build_leaf(command_id, is_group_callback=True))
-        else:
-            sub = typer.Typer(
-                help=_GROUP_DESCRIPTIONS.get(tokens[0], f"Commands for {' '.join(tokens)}."),
-                no_args_is_help=True,
-                context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
-            )
-        return sub
+def _populate(base: tuple[str, ...], group: typer.Typer) -> None:
+    """Register every command below ``base`` (exclusive) on ``group``."""
+    path_to_command, containers = _command_tree()
+    groups: dict[tuple[str, ...], typer.Typer] = {base: group}
 
     def _group_for(tokens: tuple[str, ...]) -> typer.Typer:
         if tokens in groups:
             return groups[tokens]
         parent = _group_for(tokens[:-1])
-        sub = _make_group(tokens)
+        sub = _group_typer(tokens, path_to_command.get(tokens))
         top_level = tokens[0]
         parent.add_typer(
             sub,
@@ -960,15 +976,16 @@ def build_app() -> typer.Typer:
         groups[tokens] = sub
         return sub
 
+    below = {t: c for t, c in path_to_command.items() if t[: len(base)] == base and t != base}
     # Ensure every container group exists (parents before children).
-    for tokens in sorted(containers, key=len):
+    for tokens in sorted((t for t in below if t in containers), key=len):
         _group_for(tokens)
 
     # Register every non-container command as a leaf under its parent group.
     # A command_id with a bespoke, fully-typed callback overrides the generic
     # leaf at the same registered name and path; the manifest-driven surface
     # is otherwise unchanged.
-    for tokens, command_id in sorted(path_to_command.items()):
+    for tokens, command_id in sorted(below.items()):
         if tokens in containers:
             continue
         record = command_by_id(command_id)
@@ -980,11 +997,88 @@ def build_app() -> typer.Typer:
             context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
         )(callback)
 
+
+@cache
+def _top_level_typer(name: str) -> typer.Typer:
+    """Build (once) the Typer sub-app for one top-level command group."""
+    path_to_command, _ = _command_tree()
+    sub = _group_typer((name,), path_to_command.get((name,)))
+    _populate((name,), sub)
+    return sub
+
+
+# Top-level groups are converted to Click on first use. Building the leaf
+# callbacks and ``--help`` text for all ~550 commands, then letting Typer
+# convert every one of them, used to cost most of the CLI's start-up time on
+# every invocation; a run touches one group.
+_LAZY_GROUP_NAMES: list[str] = []
+_LAZY_SETTINGS: dict[str, Any] = {}
+
+
+def _load_top_level_group(name: str) -> Any:
+    from typer.models import TyperInfo
+
+    info = TyperInfo(
+        _top_level_typer(name),
+        name=name,
+        help=_GROUP_DESCRIPTIONS.get(name, f"Commands for {name}."),
+        rich_help_panel=_ROOT_HELP_PANELS.get(name),
+    )
+    return typer.main.get_group_from_info(info, **_LAZY_SETTINGS)
+
+
+def build_app() -> typer.Typer:
+    """Construct the Typer command tree from the command manifests.
+
+    Top-level leaves (``doctor``, ``version``, ...) are registered here; every
+    top-level group is materialised by :class:`_EnvelopeGroup` on demand.
+    """
+    root = typer.Typer(
+        name="mammoth",
+        help=(
+            "Command-line interface for the Mammoth Analytics platform.\n\n"
+            "Start with 'mammoth doctor' to check access, 'mammoth schema find QUERY' "
+            "to locate a command, and 'mammoth schema get COMMAND_ID' for its full input schema."
+        ),
+        no_args_is_help=True,
+        add_completion=True,
+        cls=_EnvelopeGroup,
+        context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+    )
+
+    @root.callback()
+    def _root(
+        version: bool = typer.Option(
+            False, "--version", callback=_version_callback, is_eager=True, help="Show version."
+        ),
+    ) -> None:
+        """Root callback holding eager global options."""
+
+    path_to_command, containers = _command_tree()
+    top_names = sorted({tokens[0] for tokens in path_to_command})
+    lazy: list[str] = []
+    for name in top_names:
+        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_GROUP_NAMES[:] = lazy
+    _LAZY_SETTINGS.update(
+        pretty_exceptions_short=root.pretty_exceptions_short,
+        rich_markup_mode=root.rich_markup_mode,
+        suggest_commands=root.suggest_commands,
+    )
     return root
 
 
 def registered_command_paths() -> set[str]:
-    """Return every registered command path by walking the built Typer tree.
+    """Return every registered command path by walking the built Typer trees.
 
     Container commands (a node that is both a group and invocable) are counted
     by their own path as well as their subcommands.
@@ -998,14 +1092,20 @@ def registered_command_paths() -> set[str]:
                 paths.add(" ".join((*prefix, name)))
         for group in instance.registered_groups:
             sub = group.typer_instance
-            if sub is None or not group.name:
+            name = group.name
+            if sub is None or not name:
                 continue
-            node = (*prefix, group.name)
-            if getattr(sub.info, "invoke_without_command", False) and sub.registered_callback:
+            node = (*prefix, name)
+            if sub.registered_callback is not None:
                 paths.add(" ".join(node))
             walk(sub, node)
 
-    walk(build_app(), ())
+    walk(app, ())
+    for name in _LAZY_GROUP_NAMES:
+        sub = _top_level_typer(name)
+        if sub.registered_callback is not None:
+            paths.add(name)
+        walk(sub, (name,))
     return paths
 
 
@@ -1020,7 +1120,9 @@ def _root_click_command() -> Any:
     the tree is fixed for the process lifetime (:data:`app` is built once at
     import time).
     """
-    return typer.main.get_command(app)
+    root: Any = typer.main.get_command(app)
+    root.commands  # noqa: B018 -- materialise every lazy top-level group
+    return root
 
 
 def command_option_names(command_path: str) -> set[str]:

{mammoth_cli-2.0.30 → mammoth_cli-2.0.31}/mammoth_cli/bundled_skill/mammoth-cli/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: mammoth-cli
-version: 2.0.30
+version: 2.0.31
 description: "Use Mammoth Analytics from a terminal: install or authenticate the CLI, discover its live command contract, and safely manage projects, data, views, pipelines, dashboards, exports, and handoffs."
 ---
 

{mammoth_cli-2.0.30 → mammoth_cli-2.0.31}/mammoth_cli/bundled_skill/mammoth-cli/references/recipes/exports.md

@@ -3,10 +3,13 @@
 ```bash
 mammoth schema find "view export"
 mammoth schema get view.export.csv
-mammoth view export csv VIEW_ID --project PROJECT_ID
+mammoth view export csv VIEW_ID --project PROJECT_ID --input '{"dataset_id": DATASET_ID, "output_path": "out.csv"}'
 mammoth view export list VIEW_ID DATASET_ID --project PROJECT_ID
 ```
 
+`view export csv` takes one positional (the view); `dataset_id` and
+`output_path` go in `--input`. It is a download, not a pipeline step.
+
 If the export or its source dataset/view is requested as a deliverable, mark
 both as retained before starting. Wait/reconcile returned jobs. Verify local
 artifact headers, rows and hash;

{mammoth_cli-2.0.30 → mammoth_cli-2.0.31}/mammoth_cli/bundled_skill/mammoth-cli/references/recipes/need-action.md

@@ -30,9 +30,13 @@ mammoth dataset file-settings update DATASET_ID --project PROJECT_ID \
 ```
 
 The response is a job (`operation: "understand_csv"`). Poll `dataset get`
-until `status` leaves `need_action`; it normally reaches `ready` within a few
-seconds, after which `view list` returns the generated view and typed
-transforms can proceed. If the status becomes `error`, read `status_info`
+(the record is under `data.dataset`, so read `data.dataset.status`) until
+the status leaves `need_action`. It usually reaches `ready` within seconds;
+on prague an ISO `YYYY-MM-DD` column was flagged ambiguous and took about
+three minutes, so poll for up to five minutes before treating it as stuck.
+Then `view list` returns the generated view and typed transforms can
+proceed. Which environments ask differs: release processed the same file
+straight to `ready`. If the status becomes `error`, read `status_info`
 and stop; do not retry with guessed settings.
 
 ## All-text CSV: `ready` without a view

{mammoth_cli-2.0.30 → mammoth_cli-2.0.31}/mammoth_cli/bundled_skill/mammoth-cli/references/safety.md

@@ -44,6 +44,13 @@ mammoth view transform filter 144 --dry-run \
 # data.would_call.sdk_symbol = ...FilterOpsMixin.filter_rows, view_id 144, dataset_id 122
 ```
 
+A dry run is a full process with the same reads as the real run. On a
+hosted environment budget roughly 2 s per request (about 0.7 s of it TLS
+setup from a cold process, the rest server time), so `view task list` →
+`--dry-run` → write costs about 30–40 s per pipeline step. That is the
+price of the procedure, not a hang; do not shorten `--timeout` below the
+default to speed it up.
+
 ## Add-only edits to a pipeline someone else may touch
 
 Every `view transform *` and `view task add` accepts `expected_task_count`:

mammoth_cli-2.0.31/mammoth_cli/manifest/loader.py

@@ -0,0 +1,164 @@
+"""Load and validate the reviewed parity and command manifests.
+
+These manifests are the single source of truth for capability discovery, schema
+discovery, help generation, the agent skill, and the parity report. Runtime code
+loads them read-only; the build scripts generate them.
+"""
+
+from __future__ import annotations
+
+import functools
+import hashlib
+import json
+import os
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import platformdirs
+import yaml
+
+SPEC_ROOT = Path(__file__).resolve().parent.parent.parent / "spec"
+MANIFEST_DIR = SPEC_ROOT / "manifests"
+COMMANDS_DIR = MANIFEST_DIR / "commands"
+SCHEMA_PATH = MANIFEST_DIR / "schema-v1.json"
+OPENAPI_OPERATIONS_PATH = MANIFEST_DIR / "openapi-operations.yaml"
+SDK_METHODS_PATH = MANIFEST_DIR / "sdk-methods.yaml"
+
+MANIFEST_SCHEMA_VERSION = 1
+CACHE_ENV = "MAMMOTH_CLI_MANIFEST_CACHE"
+
+# libyaml parses the 800 KiB of command manifests in ~0.2 s; the pure-Python
+# loader takes ~2 s, which used to be most of the CLI's start-up time.
+_YAML_LOADER = getattr(yaml, "CSafeLoader", yaml.SafeLoader)
+
+
+def _read_yaml(path: Path) -> Any:
+    if not path.exists():
+        return None
+    return yaml.load(path.read_text(encoding="utf-8"), Loader=_YAML_LOADER)  # noqa: S506
+
+
+def cache_dir() -> Path:
+    """Return the directory the parsed-manifest cache lives in (not created)."""
+    return Path(platformdirs.user_cache_dir("mammoth-cli", "Mammoth"))
+
+
+def _cache_enabled() -> bool:
+    return os.environ.get(CACHE_ENV, "1").strip().lower() not in {"0", "false", "no", "off"}
+
+
+def _commands_fingerprint(paths: list[Path]) -> str:
+    """Identify the exact set of manifest files by name, size and mtime."""
+    digest = hashlib.sha256()
+    digest.update(str(MANIFEST_SCHEMA_VERSION).encode())
+    for path in paths:
+        stat = path.stat()
+        digest.update(f"{path.name}\0{stat.st_size}\0{stat.st_mtime_ns}\n".encode())
+    return digest.hexdigest()[:24]
+
+
+def _read_commands_cache(path: Path) -> list[dict[str, Any]] | None:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    if not isinstance(data, list) or not all(isinstance(item, dict) for item in data):
+        return None
+    return data
+
+
+def _write_commands_cache(path: Path, records: list[dict[str, Any]]) -> None:
+    """Write the cache atomically; a cache that cannot be written is simply skipped."""
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        fd, tmp = tempfile.mkstemp(dir=path.parent, prefix=path.name, suffix=".tmp")
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            json.dump(records, handle, separators=(",", ":"))
+        os.replace(tmp, path)
+    except OSError:
+        return
+
+
+@functools.lru_cache(maxsize=1)
+def load_schema() -> dict[str, Any]:
+    schema: dict[str, Any] = json.loads(SCHEMA_PATH.read_text(encoding="utf-8"))
+    return schema
+
+
+@functools.lru_cache(maxsize=1)
+def load_operations() -> list[dict[str, Any]]:
+    data = _read_yaml(OPENAPI_OPERATIONS_PATH)
+    if not data:
+        return []
+    return list(data.get("operations", []))
+
+
+@functools.lru_cache(maxsize=1)
+def load_sdk_methods() -> list[dict[str, Any]]:
+    data = _read_yaml(SDK_METHODS_PATH)
+    if not data:
+        return []
+    return list(data.get("methods", []))
+
+
+@functools.lru_cache(maxsize=1)
+def load_commands() -> list[dict[str, Any]]:
+    """Load every command record across all command group files, sorted by id.
+
+    The parsed records are cached as JSON under :func:`cache_dir`, keyed by the
+    manifest files' names, sizes and mtimes, so a normal invocation skips YAML
+    parsing entirely. Set ``MAMMOTH_CLI_MANIFEST_CACHE=0`` to bypass the cache.
+    """
+    if not COMMANDS_DIR.exists():
+        return []
+    paths = sorted(COMMANDS_DIR.glob("*.yaml"))
+    cache_path: Path | None = None
+    if _cache_enabled():
+        try:
+            cache_path = cache_dir() / f"commands-{_commands_fingerprint(paths)}.json"
+        except OSError:
+            cache_path = None
+        if cache_path is not None:
+            cached = _read_commands_cache(cache_path)
+            if cached is not None:
+                return cached
+    records: list[dict[str, Any]] = []
+    for path in paths:
+        data = _read_yaml(path)
+        if not data:
+            continue
+        records.extend(data.get("commands", []))
+    records.sort(key=lambda record: record["command_id"])
+    if cache_path is not None:
+        _write_commands_cache(cache_path, records)
+    return records
+
+
+@dataclass(frozen=True)
+class ManifestSet:
+    operations: list[dict[str, Any]]
+    sdk_methods: list[dict[str, Any]]
+    commands: list[dict[str, Any]]
+
+
+def load_all() -> ManifestSet:
+    return ManifestSet(
+        operations=load_operations(),
+        sdk_methods=load_sdk_methods(),
+        commands=load_commands(),
+    )
+
+
+def command_by_id(command_id: str) -> dict[str, Any] | None:
+    for record in load_commands():
+        if record["command_id"] == command_id:
+            return record
+    return None
+
+
+def clear_cache() -> None:
+    """Reset cached manifests (used in tests that rewrite manifest files)."""
+    for func in (load_schema, load_operations, load_sdk_methods, load_commands):
+        func.cache_clear()

{mammoth_cli-2.0.30 → mammoth_cli-2.0.31}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mammoth-cli"
-version = "2.0.30"
+version = "2.0.31"
 description = "Command-line interface for the Mammoth Analytics platform"
 authors = [{name = "Mammoth Analytics", email = "support@mammoth.io"}]
 readme = "README.md"

mammoth_cli-2.0.30/mammoth_cli/manifest/loader.py

@@ -1,96 +0,0 @@
-"""Load and validate the reviewed parity and command manifests.
-
-These manifests are the single source of truth for capability discovery, schema
-discovery, help generation, the agent skill, and the parity report. Runtime code
-loads them read-only; the build scripts generate them.
-"""
-
-from __future__ import annotations
-
-import functools
-import json
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any
-
-import yaml
-
-SPEC_ROOT = Path(__file__).resolve().parent.parent.parent / "spec"
-MANIFEST_DIR = SPEC_ROOT / "manifests"
-COMMANDS_DIR = MANIFEST_DIR / "commands"
-SCHEMA_PATH = MANIFEST_DIR / "schema-v1.json"
-OPENAPI_OPERATIONS_PATH = MANIFEST_DIR / "openapi-operations.yaml"
-SDK_METHODS_PATH = MANIFEST_DIR / "sdk-methods.yaml"
-
-MANIFEST_SCHEMA_VERSION = 1
-
-
-def _read_yaml(path: Path) -> Any:
-    if not path.exists():
-        return None
-    return yaml.safe_load(path.read_text(encoding="utf-8"))
-
-
-@functools.lru_cache(maxsize=1)
-def load_schema() -> dict[str, Any]:
-    schema: dict[str, Any] = json.loads(SCHEMA_PATH.read_text(encoding="utf-8"))
-    return schema
-
-
-@functools.lru_cache(maxsize=1)
-def load_operations() -> list[dict[str, Any]]:
-    data = _read_yaml(OPENAPI_OPERATIONS_PATH)
-    if not data:
-        return []
-    return list(data.get("operations", []))
-
-
-@functools.lru_cache(maxsize=1)
-def load_sdk_methods() -> list[dict[str, Any]]:
-    data = _read_yaml(SDK_METHODS_PATH)
-    if not data:
-        return []
-    return list(data.get("methods", []))
-
-
-@functools.lru_cache(maxsize=1)
-def load_commands() -> list[dict[str, Any]]:
-    """Load every command record across all command group files, sorted by id."""
-    records: list[dict[str, Any]] = []
-    if not COMMANDS_DIR.exists():
-        return []
-    for path in sorted(COMMANDS_DIR.glob("*.yaml")):
-        data = _read_yaml(path)
-        if not data:
-            continue
-        records.extend(data.get("commands", []))
-    records.sort(key=lambda record: record["command_id"])
-    return records
-
-
-@dataclass(frozen=True)
-class ManifestSet:
-    operations: list[dict[str, Any]]
-    sdk_methods: list[dict[str, Any]]
-    commands: list[dict[str, Any]]
-
-
-def load_all() -> ManifestSet:
-    return ManifestSet(
-        operations=load_operations(),
-        sdk_methods=load_sdk_methods(),
-        commands=load_commands(),
-    )
-
-
-def command_by_id(command_id: str) -> dict[str, Any] | None:
-    for record in load_commands():
-        if record["command_id"] == command_id:
-            return record
-    return None
-
-
-def clear_cache() -> None:
-    """Reset cached manifests (used in tests that rewrite manifest files)."""
-    for func in (load_schema, load_operations, load_sdk_methods, load_commands):
-        func.cache_clear()