mammoth-cli 2.2.4__tar.gz → 2.2.5__tar.gz

{mammoth_cli-2.2.4 → mammoth_cli-2.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.2.4
+Version: 2.2.5
 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.5
+Requires-Dist: mammoth-io<0.9,>=0.8.6
 Requires-Dist: platformdirs<5,>=4.10
 Requires-Dist: pydantic<3,>=2.12.5
 Requires-Dist: pyyaml<7,>=6
@@ -212,8 +212,7 @@ Onboard me first:
    `recommendation`, print exactly this and wait until I say done: "In the
    Mammoth web app open Workspace settings → API Tokens → Create token (no
    project, so I can create projects), copy the token (it starts with mm_ and
-   is shown once), and note the workspace id (the number after /workspaces/
-   in the address bar), then run in your own terminal: mammoth auth login" —
+   is shown once), then run in your own terminal: mammoth auth login" —
    never ask for, read, or pass the token yourself, and never run auth login.
 3. Require `mammoth doctor` to pass, then run `mammoth skill show` and
    follow the guide it prints.

{mammoth_cli-2.2.4 → mammoth_cli-2.2.5}/README.md

@@ -184,8 +184,7 @@ Onboard me first:
    `recommendation`, print exactly this and wait until I say done: "In the
    Mammoth web app open Workspace settings → API Tokens → Create token (no
    project, so I can create projects), copy the token (it starts with mm_ and
-   is shown once), and note the workspace id (the number after /workspaces/
-   in the address bar), then run in your own terminal: mammoth auth login" —
+   is shown once), then run in your own terminal: mammoth auth login" —
    never ask for, read, or pass the token yourself, and never run auth login.
 3. Require `mammoth doctor` to pass, then run `mammoth skill show` and
    follow the guide it prints.

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

{mammoth_cli-2.2.4 → mammoth_cli-2.2.5}/mammoth_cli/bundled_skill/mammoth-cli/references/auth.md

@@ -1,6 +1,6 @@
 # Authentication and profiles
 
-Required: an API token (`mm_...`) and a workspace id. Optional: a one-label
+Required: an API token (`mm_...`); it names its own workspace. Optional: a one-label
 server prefix (default `app`, resolving to `https://app.mammoth.io/api/v2`).
 Login accepts nothing else. If `auth status` reports `credential: key_secret`
 (a profile saved by an older CLI), it still works, but ask the operator to run
@@ -29,8 +29,7 @@ human operator:
 1. Tell the operator where the credentials come from: in the Mammoth web app,
    **Workspace settings → API Tokens → Create token** gives a token that
    starts with `mm_`; the web app shows it only once (if it is lost, create a
-   new one). The workspace id is the number after `/workspaces/`
-   in the web app's address bar. Then give the exact command to run in
+   new one). Then give the exact command to run in
    **their own** terminal. For production it is:
 
    ```bash
@@ -40,7 +39,7 @@ human operator:
    Add `--server-prefix release` only when the task names the release
    environment, and `--profile NAME` only when the operator wants a profile
    other than `default`. The command prompts for the token with hidden
-   input, then the workspace id, so no secret enters chat, argv, or history.
+   input, so no secret enters chat, argv, or history.
    Tokens are per environment and per workspace: a release token never
    authenticates on `app`.
    On macOS the Keychain may show a dialog about `mammoth-cli`; tell the
@@ -54,7 +53,7 @@ human operator:
    `auth login` yourself, with or without `--input`, unless the operator has
    explicitly given you a protected `0600` credential file path to use.
 
-The only supported configuration is the API token, the workspace id, and an optional one-label server prefix (default `app`). There is no base-url
+The only supported configuration is the API token and an optional one-label server prefix (default `app`). There is no base-url
 override.
 
 ## Cold-start sequence
@@ -123,7 +122,7 @@ file backend as a secret store; use the OS keyring or stop and obtain a
 supported secure store. Remove any input file after the
 profile is stored.
 
-`creds.json` is a `0600` JSON file: `{"api_token": "mm_...", "workspace_id": 4,
+`creds.json` is a `0600` JSON file: `{"api_token": "mm_...",
 "server_prefix": "app"}` (`server_prefix` optional). You can
 also pipe it with `--input - --input-format json`.
 

{mammoth_cli-2.2.4 → mammoth_cli-2.2.5}/mammoth_cli/bundled_skill/mammoth-cli/references/capabilities.md

@@ -1,7 +1,7 @@
 # What is proven on release
 
 Generated from `docs/release-capability-matrix.json`; do not edit by hand.
-The CLI publishes 595 commands. 455 of them bind one of the 528 API operations in the matrix; the remainder are local commands (`schema`, `auth`, `doctor`, `log`, ...) or typed variants that share an operation (`view transform *` commands submit through `view.task.add`, except `rename-columns` and `sort`, which set view display properties through `view.update`). 262 bound commands ran once successfully on release, 2 are not supported there, and the rest are untried. Untried is not broken: discover the contract with `mammoth schema get COMMAND_ID`, run it, and treat the structured error envelope as the answer. Use an untried command normally: confirm a write with the user first, check its result with a read afterwards, and never refuse a command only because it is untried.
+The CLI publishes 597 commands. 455 of them bind one of the 528 API operations in the matrix; the remainder are local commands (`schema`, `auth`, `doctor`, `log`, ...) or typed variants that share an operation (`view transform *` commands submit through `view.task.add`, except `rename-columns` and `sort`, which set view display properties through `view.update`). 262 bound commands ran once successfully on release, 2 are not supported there, and the rest are untried. Untried is not broken: discover the contract with `mammoth schema get COMMAND_ID`, run it, and treat the structured error envelope as the answer. Use an untried command normally: confirm a write with the user first, check its result with a read afterwards, and never refuse a command only because it is untried.
 
 Status meanings:
 

{mammoth_cli-2.2.4 → mammoth_cli-2.2.5}/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 595; 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 597; 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:
 
@@ -25,12 +25,13 @@ Load only the applicable domain file:
 - [dashboard-style](commands/dashboard-style.md) — 10 published commands
 - [dashboard](commands/dashboard.md) — 93 published commands
 - [data-app](commands/data-app.md) — 12 published commands
-- [dataset](commands/dataset.md) — 20 published commands
+- [dataset](commands/dataset.md) — 21 published commands
 - [doctor](commands/doctor.md) — 1 published commands
 - [external-key](commands/external-key.md) — 4 published commands
 - [file](commands/file.md) — 9 published commands
 - [folder](commands/folder.md) — 10 published commands
 - [job](commands/job.md) — 4 published commands
+- [link](commands/link.md) — 1 published commands
 - [log](commands/log.md) — 2 published commands
 - [notification](commands/notification.md) — 5 published commands
 - [parameter](commands/parameter.md) — 14 published commands

{mammoth_cli-2.2.4 → mammoth_cli-2.2.5}/mammoth_cli/bundled_skill/mammoth-cli/references/commands/dataset.md

@@ -22,6 +22,16 @@ Result: `DatasetBrokenRowsListResult`; mutation `read`, confirmation `none`, wai
 
 Status on release: untried; no live run recorded.
 
+### `dataset.broken-rows.resolve`
+
+Run: `mammoth dataset broken-rows resolve`. Exact input fields: `mammoth schema get dataset.broken-rows.resolve`.
+
+Example: `mammoth dataset broken-rows resolve 123 --input '{"op": "add", "batch_id": 1, "rows": [{"sample_key": "Status"}]}'`. Illustrative only: append `--yes` after observing an owned target.
+
+Result: `DatasetBrokenRowsResolveResult`; mutation `destructive`, confirmation `prompt_or_yes`, wait policy `not_async`.
+
+Status on release: untried; no live run recorded.
+
 ### `dataset.bulk-delete`
 
 Run: `mammoth dataset bulk-delete`. Exact input fields: `mammoth schema get dataset.bulk-delete`.

mammoth_cli-2.2.5/mammoth_cli/bundled_skill/mammoth-cli/references/commands/link.md

@@ -0,0 +1,13 @@
+# `link` 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 (use it normally: confirm writes with the user, check the result afterwards), *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).
+
+### `link`
+
+Run: `mammoth link`. Exact input fields: `mammoth schema get link`.
+
+Example: `mammoth link https://app.mammoth.io/workspaces/1/projects/2/data/datasets`. Placeholders are illustrative; resolve IDs and input from observed reads.
+
+Result: `LinkResult`; mutation `read`, confirmation `none`, wait policy `not_async`.
+
+Status on release: untried; no live run recorded.

{mammoth_cli-2.2.4 → mammoth_cli-2.2.5}/mammoth_cli/bundled_skill/mammoth-cli/references/recipes/need-action.md

@@ -58,3 +58,39 @@ mammoth view list DATASET_ID --project PROJECT_ID    # the new view, row_count s
 The new view is ready at once and takes transforms like any other (verified
 on release, 2026-09-24). Run `view create` only when `view list DATASET_ID`
 is empty, so that a retry does not add a second view.
+
+## A pasted link to a file with "Unstructured rows"
+
+`mammoth project needs-attention --project PROJECT_ID` lists it as a
+`needs_input` row with `action: "unstructured_rows"` and the `dataset_id`.
+The Monitor panel lists this as **Unstructured rows** ("header and data rows
+need mapping"): some lines of an uploaded file did not fit the dataset's
+columns and were set aside, so the dataset waits for a person. Turn the pasted
+address into ids first; it makes no request:
+
+```bash
+mammoth link 'https://app.mammoth.io/workspaces/1/projects/2/data/folders/3?selectedResourceId=4'
+```
+
+The folder and `selected_resource_id` in a link are resource ids, not dataset
+ids: find the dataset with `mammoth dataset find NAME`. Then read the set-aside
+lines and why each one does not fit (the first 100, with `row_count` the total):
+
+```bash
+mammoth dataset broken-rows list DATASET_ID --project PROJECT_ID
+```
+
+Then fix them, with the user's confirmation. Take a line in after correcting
+it so its column count matches, or discard it (discarded lines do not come
+back; say so first). `batch_id` and `line_num` come from the list:
+
+```bash
+mammoth dataset broken-rows resolve DATASET_ID --project PROJECT_ID \
+  --input '{"op": "remove", "batch_id": 7, "rows": [{"line_num": 4, "line": ""}]}'
+mammoth job wait JOB_ID
+mammoth dataset broken-rows list DATASET_ID --project PROJECT_ID   # row_count 0 = done
+```
+
+`op: "add"` takes the corrected `line` of each row in instead. The same step is
+**Review & Fix** in the app. Do not tell the user to open the Monitor item's
+link.

{mammoth_cli-2.2.4 → mammoth_cli-2.2.5}/mammoth_cli/commands/auth.py

@@ -1,8 +1,9 @@
 """Bespoke `auth` command family: login, status, logout.
 
-Authentication needs an API token (``mm_...``, sent as ``Authorization:
-Bearer``) and a workspace id, plus an optional server prefix (default
-``app``). There is no environment credential path. These commands never accept a secret as an
+Authentication needs only an API token (``mm_...``, sent as ``Authorization:
+Bearer``), plus an optional server prefix (default ``app``). The token names its
+own workspace, which login learns from the server. There is no environment
+credential path. These commands never accept a secret as an
 ordinary command-line value: it comes from a hidden TTY prompt or a
 permission-checked JSON/YAML login document read through ``--input``.
 """
@@ -18,18 +19,14 @@ from typing import Any, cast
 import typer
 from pydantic import ValidationError
 
-from mammoth_cli.context import credentials, profiles
+from mammoth_cli.context import credentials, profiles, resolver
 from mammoth_cli.context.endpoint import resolve_base_url
-from mammoth_cli.context.resolver import (
-    ResolvedAuth,
-    resolve_auth,
-)
+from mammoth_cli.context.resolver import ResolvedAuth, resolve_auth
 from mammoth_cli.contracts.auth import LoginRequest
 from mammoth_cli.errors.envelope import (
     CODE_AUTHENTICATION_FAILED,
     CODE_CONFIRMATION_DECLINED,
     CODE_CONFIRMATION_REQUIRED,
-    CODE_INVALID_WORKSPACE_ID,
     EXIT_USAGE,
     CliError,
 )
@@ -128,7 +125,7 @@ def _validate_login_document(document: dict[str, Any]) -> LoginRequest:
             message="The login request document failed validation.",
             exit_status=EXIT_USAGE,
             hint=(
-                'Expected {"api_token": "mm_...", "workspace_id": N} with an optional '
+                'Expected {"api_token": "mm_..."} with an optional '
                 '"server_prefix". API key + secret pairs are no longer accepted; create '
                 "a token in Workspace settings -> API Tokens."
             ),
@@ -217,6 +214,59 @@ def _prompt_blockers(invocation: Invocation) -> list[str]:
     return reasons
 
 
+def _verify_login(invocation: Invocation, *, base_url: str, api_token: str) -> int:
+    """Learn the token's workspace from the server and run the connection check.
+
+    Nothing is saved here; a failure leaves existing profile state unchanged.
+
+    Returns:
+        The workspace id the server reports for the token.
+
+    Raises:
+        CliError: ``authentication_failed`` (with the endpoint and a masked
+            receipt of the token) when the server rejects it; any other mapped
+            transport error as is.
+    """
+    try:
+        workspace_id = resolver.resolve_token_workspace(base_url, api_token, invocation.timeout)
+        service = service_factory.build_service(
+            ResolvedAuth(
+                api_key=None,
+                api_secret=None,
+                workspace_id=workspace_id,
+                base_url=base_url,
+                api_token=api_token,
+            ),
+            timeout=invocation.timeout,
+        )
+        try:
+            service.check_connection()
+        finally:
+            service.close()
+    except CliError as exc:
+        if exc.code == CODE_AUTHENTICATION_FAILED:
+            # Say exactly what was tried, without the secret: the endpoint and
+            # a masked receipt of the token. Credentials are per environment,
+            # and a release token typed at a production login is the common
+            # cause of an otherwise opaque 401.
+            exc.details = {
+                **exc.details,
+                "endpoint_base_url": base_url,
+                # A receipt only (length and last four characters). The output
+                # layer redacts any key that looks like a credential, so this
+                # is named for what it is: a description, not the value.
+                "credential_receipt": {"type": "api token", "shape": _masked_receipt(api_token)},
+            }
+            exc.hint = (
+                f"{base_url} rejected this token. Credentials are per environment: "
+                "a token issued on one Mammoth server does not authenticate on "
+                "another. Check the token and that --server-prefix matches where "
+                "it was issued."
+            )
+        raise
+    return workspace_id
+
+
 def _run_login(
     invocation: Invocation,
     *,
@@ -234,7 +284,6 @@ def _run_login(
 
     blockers = _prompt_blockers(invocation)
 
-    effective_workspace: int | None
     if invocation.input_file is not None:
         # The permission check is deliberately separate from parsing so a
         # secret-bearing file is rejected before any bytes are read.  The
@@ -246,15 +295,12 @@ def _run_login(
         request = _validate_login_document(document)
         api_token = request.api_token.strip()
         _check_token_shape(api_token)
-        effective_workspace = request.workspace_id
         effective_prefix = server_prefix if server_prefix is not None else request.server_prefix
     elif not blockers:
-        # Two flows, nothing else: a terminal prompts for everything (token,
-        # then workspace id), and non-interactive uses --input. The workspace
-        # is asked last, after the credential.
+        # Two flows, nothing else: a terminal prompts for the token, and
+        # non-interactive uses --input.
         api_token = _prompt_secret("API token")
         _check_token_shape(api_token)
-        effective_workspace = typer.prompt("Workspace id", type=int)
         effective_prefix = server_prefix
     else:
         raise CliError(
@@ -269,49 +315,8 @@ def _run_login(
             ),
         )
 
-    if effective_workspace is None or effective_workspace <= 0:
-        raise CliError(
-            code=CODE_INVALID_WORKSPACE_ID,
-            message="A positive --workspace id is required.",
-            exit_status=EXIT_USAGE,
-        )
     resolved_base_url = resolve_base_url(effective_prefix)
-
-    resolved_auth = ResolvedAuth(
-        api_key=None,
-        api_secret=None,
-        workspace_id=effective_workspace,
-        base_url=resolved_base_url,
-        api_token=api_token,
-    )
-    service = service_factory.build_service(resolved_auth, timeout=invocation.timeout)
-    try:
-        service.check_connection()
-    except CliError as exc:
-        if exc.code == CODE_AUTHENTICATION_FAILED:
-            # Say exactly what was tried, without the secret: the endpoint,
-            # the workspace, and a masked receipt of the key. Credentials are
-            # per environment, and a release key typed at a production login
-            # is the common cause of an otherwise opaque 401.
-            exc.details = {
-                **exc.details,
-                "endpoint_base_url": resolved_base_url,
-                "workspace_id": effective_workspace,
-                # A receipt only (length and last four characters). The output
-                # layer redacts any key that looks like a credential, so this
-                # is named for what it is: a description, not the value.
-                "credential_receipt": {"type": "api token", "shape": _masked_receipt(api_token)},
-            }
-            exc.hint = (
-                f"{resolved_base_url} rejected this token for workspace "
-                f"{effective_workspace}. Credentials are per environment and per workspace: "
-                "a token issued on one Mammoth server or workspace does not authenticate on "
-                "another. Check the token, the workspace id, and that --server-prefix "
-                "matches where it was issued."
-            )
-        raise
-    finally:
-        service.close()
+    effective_workspace = _verify_login(invocation, base_url=resolved_base_url, api_token=api_token)
 
     profile_name = invocation.profile or profiles.DEFAULT_PROFILE_NAME
     profiles.validate_profile_name(profile_name)
@@ -366,8 +371,8 @@ def auth_login(
     """Log in and store one profile's credentials.
 
     Prompts for the API token (mm_..., from Workspace settings -> API Tokens)
-    and the workspace id in a terminal. For non-interactive use (agents, CI), pass
-    ``--input FILE`` with {"api_token": ..., "workspace_id": ...} instead.
+    in a terminal; the token names its workspace. For non-interactive use
+    (agents, CI), pass ``--input FILE`` with {"api_token": ...} instead.
     Performs a lightweight connection check before saving anything; a failed
     check leaves existing profile state unchanged.
     """

{mammoth_cli-2.2.4 → mammoth_cli-2.2.5}/mammoth_cli/commands/dataset.py

@@ -37,6 +37,7 @@ from mammoth_cli.services.listing import (
     fit_budget,
     name_hit,
     search_page,
+    source_of,
 )
 
 HandlerResult = tuple[Any, dict[str, Any]]
@@ -142,16 +143,9 @@ def _require_string_positional(invocation: Invocation, name: str) -> str:
     return str(invocation.extra_args[0])
 
 
-# The projects endpoint accepts at most limit=100 and exposes no offset, so a
-# cross-project search can see at most 100 projects; the result says when the
-# list was cut there.
-_MAX_PROJECTS_SEARCHED = 100
-
-
 def _visible_projects(service: Any) -> list[dict[str, Any]]:
-    """The projects the credential can see (at most ``_MAX_PROJECTS_SEARCHED``)."""
-    listing = service.list_projects(limit=_MAX_PROJECTS_SEARCHED)
-    return list(listing.get("projects", [])) if isinstance(listing, dict) else []
+    """Every project the credential is a member of, across all pages."""
+    return list(service.list_all_projects())
 
 
 def _find_in_projects(
@@ -163,7 +157,11 @@ def _find_in_projects(
         project_id = project.get("id")
         if project_id is None:
             continue
-        response = service.call("mammoth.api.datasets.DatasetsAPI.list_all", project_id=project_id)
+        response = service.call(
+            "mammoth.api.datasets.DatasetsAPI.list_all",
+            project_id=project_id,
+            fields=DATASET_ROW_FIELDS,
+        )
         datasets = response.get("datasets", []) if isinstance(response, dict) else []
         for dataset in datasets:
             name = dataset.get("name") if isinstance(dataset, dict) else None
@@ -173,6 +171,7 @@ def _find_in_projects(
                         "project_id": project_id,
                         "project_name": project.get("name"),
                         **name_hit(dataset),
+                        "source": source_of(dataset),
                     }
                 )
     return matches
@@ -231,7 +230,6 @@ def dataset_find(invocation: Invocation) -> HandlerResult:
     result: dict[str, Any] = {
         "matches": matches,
         "projects_searched": len(projects),
-        "projects_truncated": len(projects) >= _MAX_PROJECTS_SEARCHED,
     }
     if note := ambiguity_note(len(matches), name_substring):
         result["note"] = note
@@ -454,6 +452,33 @@ def dataset_broken_rows(invocation: Invocation) -> HandlerResult:
     return _read_dataset(invocation)
 
 
+def dataset_broken_rows_resolve(invocation: Invocation) -> HandlerResult:
+    """Add corrected set-aside lines to a dataset, or discard them. Prompt or ``--yes``.
+
+    ``--input`` carries ``op`` (``add`` or ``remove``), ``batch_id`` and ``rows``
+    (``{"line_num", "line"}`` each, from ``dataset broken-rows list``). Returns a
+    job to wait on.
+    """
+    project_id = require_project(invocation)
+    dataset_id = _require_int_positional(invocation, "dataset id")
+    document = invocation.load_input()
+    kwargs: dict[str, Any] = {
+        "dataset_id": dataset_id,
+        "op": _require_field(document, "op"),
+        "batch_id": _require_field(document, "batch_id"),
+        "rows": _require_field(document, "rows"),
+        "project_id": project_id,
+    }
+    enforce_confirmation(
+        invocation,
+        policy=POLICY_PROMPT_OR_YES,
+        action=f"{kwargs['op']} set-aside lines of dataset {dataset_id}",
+    )
+    with open_service(invocation) as (service, auth):
+        data = service.call(_symbol(invocation), **kwargs)
+    return data, _meta(invocation, auth.workspace_id, project_id)
+
+
 def _read_dataset(invocation: Invocation) -> HandlerResult:
     """Call this command's SDK read with the DATASET_ID positional."""
     project_id = require_project(invocation)

{mammoth_cli-2.2.4 → mammoth_cli-2.2.5}/mammoth_cli/commands/folder.py

@@ -104,12 +104,6 @@ def _require_string_positional(invocation: Invocation, name: str) -> str:
     return str(invocation.extra_args[0])
 
 
-# The projects endpoint accepts at most limit=100 and exposes no offset, so a
-# cross-project search can see at most 100 projects; the result says when the
-# list was cut there.
-_MAX_PROJECTS_SEARCHED = 100
-
-
 def folder_find(invocation: Invocation) -> HandlerResult:
     """Search folder names for a substring across every visible project.
 
@@ -122,8 +116,7 @@ def folder_find(invocation: Invocation) -> HandlerResult:
     needle = name_substring.lower()
     matches: list[dict[str, Any]] = []
     with open_service(invocation) as (service, auth):
-        listing = service.list_projects(limit=_MAX_PROJECTS_SEARCHED)
-        visible = list(listing.get("projects", [])) if isinstance(listing, dict) else []
+        visible = list(service.list_all_projects())
         if invocation.project is not None:
             projects: list[dict[str, Any]] = [named_project(service, invocation.project, visible)]
         else:
@@ -157,9 +150,6 @@ def folder_find(invocation: Invocation) -> HandlerResult:
     return {
         "matches": matches,
         "projects_searched": len(projects),
-        "projects_truncated": (
-            invocation.project is None and len(projects) >= _MAX_PROJECTS_SEARCHED
-        ),
     }, meta
 
 

mammoth_cli-2.2.5/mammoth_cli/commands/link.py

@@ -0,0 +1,89 @@
+"""The ``link`` command: local, read-only, turns a pasted Mammoth app URL into ids.
+
+A user pastes a link from the web app (``.../workspaces/W/projects/P/data/folders/F
+?selectedResourceId=R``, a dataset or view editor link, a dashboard link) and asks
+about the item behind it. Every id in the link is already there, so reading it
+needs no server; ``link`` is the one place that knows the app's route shapes, so
+an agent does not guess which number is which.
+
+The route shapes mirror the web app's router (mm-frontend ``data-library``,
+``data-editor``, ``workflows``, ``dashboard`` and ``data-apps`` route files).
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+from urllib.parse import parse_qs, urlparse
+
+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]]
+
+#: ``(pattern, field)``: each pattern captures one id out of the URL path.
+_PATH_IDS: tuple[tuple[re.Pattern[str], str], ...] = (
+    (re.compile(r"/workspaces/(\d+)(?:/|$)"), "workspace_id"),
+    (re.compile(r"/projects/(\d+)(?:/|$)"), "project_id"),
+    (re.compile(r"/data/folders/(\d+)(?:/|$)"), "folder_resource_id"),
+    (re.compile(r"/datasets/(\d+)(?:/|$)"), "dataset_id"),
+    (re.compile(r"/(?:views|dataviews)/(\d+)(?:/|$)"), "view_id"),
+    (re.compile(r"/dashboard/(\d+)(?:/|$)"), "dashboard_id"),
+    (re.compile(r"/data-apps/(\d+)(?:/|$)"), "data_app_id"),
+    (re.compile(r"/workflows/(\d+)(?:/|$)"), "workflow_id"),
+)
+
+#: Resource ids differ from dataset/view ids; said whenever the link carries one.
+_RESOURCE_ID_NOTE = (
+    "folder_resource_id and selected_resource_id are the web app's resource ids, not "
+    "dataset or view ids: never pass them as DATASET_ID or VIEW_ID. Find the item "
+    "with 'mammoth dataset find NAME' or 'mammoth dataset list --project PROJECT_ID'."
+)
+
+
+def _parse_error(url: str) -> CliError:
+    return CliError(
+        code=CODE_INVALID_ARGUMENT,
+        message=f"{url!r} is not a Mammoth app link (no /workspaces/ID in its path).",
+        exit_status=EXIT_USAGE,
+        hint="Paste the full address from the browser, for example "
+        "https://app.mammoth.io/workspaces/1/projects/2/data/datasets.",
+    )
+
+
+def parse_app_link(url: str) -> dict[str, Any]:
+    """Ids carried by one Mammoth app URL; absent ones are left out. Pure, no network."""
+    parsed = urlparse(url.strip())
+    path = parsed.path or ""
+    found: dict[str, Any] = {"url": url.strip()}
+    for pattern, field in _PATH_IDS:
+        match = pattern.search(path)
+        if match is not None:
+            found[field] = int(match.group(1))
+    if "workspace_id" not in found:
+        raise _parse_error(url)
+    query = parse_qs(parsed.query)
+    for key, field in (("selectedResourceId", "selected_resource_id"), ("openSection", "section")):
+        if query.get(key):
+            value = query[key][0]
+            found[field] = int(value) if value.isdigit() else value
+    if "folder_resource_id" in found or "selected_resource_id" in found:
+        found["note"] = _RESOURCE_ID_NOTE
+    return found
+
+
+def link(invocation: Invocation) -> HandlerResult:
+    """Read the workspace, project, folder, dataset and view ids out of a pasted app URL.
+
+    The sole positional argument is the URL. Returns only the ids the link
+    carries; makes no request.
+    """
+    url = invocation.extra_args[0] if invocation.extra_args else None
+    if not url or not url.strip():
+        raise CliError(
+            code=CODE_INVALID_ARGUMENT,
+            message="link requires a Mammoth app URL argument.",
+            exit_status=EXIT_USAGE,
+            hint="Pass the pasted link in quotes: mammoth link 'https://app.mammoth.io/...'.",
+        )
+    return parse_app_link(url), {}

{mammoth_cli-2.2.4 → mammoth_cli-2.2.5}/mammoth_cli/commands/registry.py

@@ -39,6 +39,7 @@ from mammoth_cli.commands import external_key as external_key_cmd
 from mammoth_cli.commands import file as file_cmd
 from mammoth_cli.commands import folder as folder_cmd
 from mammoth_cli.commands import job as job_cmd
+from mammoth_cli.commands import link as link_cmd
 from mammoth_cli.commands import notification as notification_cmd
 from mammoth_cli.commands import parameter as parameter_cmd
 from mammoth_cli.commands import project as project_cmd
@@ -234,6 +235,7 @@ HANDLERS: dict[str, Handler] = {
     "log.tail": _log_tail,
     "doctor": doctor_cmd.doctor,
     "calc": calc_cmd.calc,
+    "link": link_cmd.link,
     "completion.show": completion_cmd.completion_show,
     "completion.install": completion_cmd.completion_install,
     "skill.agents-md.install": skill_cmd.skill_agents_md_install,
@@ -322,6 +324,7 @@ HANDLERS: dict[str, Handler] = {
     "dataset.file-settings.update": dataset_cmd.dataset_file_settings_update,
     "dataset.file-settings.undo": dataset_cmd.dataset_file_settings_undo,
     "dataset.broken-rows.list": dataset_cmd.dataset_broken_rows,
+    "dataset.broken-rows.resolve": dataset_cmd.dataset_broken_rows_resolve,
     "dataset.interpretation.preview": dataset_cmd.dataset_interpretation,
     "dataset.interpretation.confirm": dataset_cmd.dataset_interpretation,
     "dataset.create": dataset_cmd.dataset_create,

{mammoth_cli-2.2.4 → mammoth_cli-2.2.5}/mammoth_cli/commands/schema.py

@@ -378,8 +378,24 @@ _COMMAND_DISCOVERY_PURPOSES = {
     "project.pending-changes": (
         "source changes new rows not taken in yet pending updates waiting to apply"
     ),
+    # "I pasted a link to a file / dataset / view -- what is wrong with it?" (zulip
+    # Mammoth Agents, ws 247): the agent had no way to turn the app address into
+    # ids, and the unstructured-rows read said "broken" where users say "unstructured".
+    "link": (
+        "link url pasted address app page open file dataset view folder project "
+        "workspace ids selected resource parse"
+    ),
+    "dataset.broken-rows.list": (
+        "unstructured skipped ragged rows lines unparsed mismatched columns monitor "
+        "needs review file upload bad rows"
+    ),
+    "dataset.broken-rows.resolve": (
+        "fix unstructured skipped ragged lines discard correct resolve mismatched "
+        "columns review monitor needs review upload"
+    ),
     "project.needs-attention": (
-        "monitor needs attention error failing pipeline views delete datasets behind list"
+        "monitor needs attention error failing pipeline views delete datasets behind list "
+        "unstructured pending review"
     ),
     "project.resource-status": "stuck stale failing broken error status anything wrong health",
     "connector.ai.chat": (