deepsieve-cli 0.1.0__tar.gz → 0.2.0__tar.gz

{deepsieve_cli-0.1.0 → deepsieve_cli-0.2.0}/.gitignore

@@ -17,7 +17,20 @@
 .aws/
 
 # --- Node / Next.js (site) ---
-site/node_modules/
+# Unanchored on purpose: `site/node_modules/` alone left a ROOT-level
+# node_modules/ tracked, and running vitest from the repo root (rather than from
+# site/) creates one — `node_modules/.vite/vitest/**/results.json` reached
+# `development` in #320 through a `git add -A`, passing review and CI without
+# anything failing. A rule that covers the path someone already hit is not a rule.
+# ⚠️ NO TRAILING SLASH, and that is load-bearing too. `node_modules/` matches
+# DIRECTORIES ONLY, so a SYMLINKED node_modules is not ignored and `git add -A`
+# stages the link itself — an absolute path that resolves for nobody else (gh
+# #756). Symlinking it is the documented way to share one 733 MB install across
+# git worktrees on a full disk, so the ignore rule and the disk guidance
+# disagreed silently. Verified by controlled test: with `node_modules/`,
+# `git add -A` reports `A  node_modules`; without the slash it reports nothing.
+node_modules
+site/node_modules
 site/.next/
 site/.next-*/
 site/out/
@@ -113,4 +126,9 @@ api/_stress/
 # Stray Playwright accessibility-snapshot dumps from browser-driven QA.
 ctx*-run.md
 page-*.yml
-user-testing/
+
+# Antigravity worktrees and state
+.gemini/
+
+# Antigravity (Gemini) agent local config — per-machine, like .claude/settings.local.json
+.agents/

{deepsieve_cli-0.1.0 → deepsieve_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: deepsieve-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: DeepSieve CLI — run cited deep research from your terminal
 Requires-Python: >=3.11
 Requires-Dist: httpx>=0.27
@@ -29,6 +29,7 @@ deepsieve runs create --query "..." --wait    # real run: spends credits
 deepsieve runs list
 deepsieve runs get <id>                       # exit 4 while still running
 deepsieve runs cancel <id>
+deepsieve members list                        # who is in the workspace + seat usage
 deepsieve data catalog                        # entities + columns (never guess)
 deepsieve data get companies --receipts       # rows with per-cell citations
 deepsieve setup mcp                           # MCP registration for this origin

{deepsieve_cli-0.1.0 → deepsieve_cli-0.2.0}/README.md

@@ -21,6 +21,7 @@ deepsieve runs create --query "..." --wait    # real run: spends credits
 deepsieve runs list
 deepsieve runs get <id>                       # exit 4 while still running
 deepsieve runs cancel <id>
+deepsieve members list                        # who is in the workspace + seat usage
 deepsieve data catalog                        # entities + columns (never guess)
 deepsieve data get companies --receipts       # rows with per-cell citations
 deepsieve setup mcp                           # MCP registration for this origin

{deepsieve_cli-0.1.0 → deepsieve_cli-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepsieve-cli"
-version = "0.1.0"
+version = "0.2.0"
 description = "DeepSieve CLI — run cited deep research from your terminal"
 requires-python = ">=3.11"
 readme = "README.md"

{deepsieve_cli-0.1.0 → deepsieve_cli-0.2.0}/src/deepsieve_cli/main.py

@@ -238,8 +238,11 @@ def cmd_runs_get(args) -> int:
 
 def cmd_runs_create(args) -> int:
     client, prof = _require_auth(args)
-    if bool(args.query) == bool(args.seeds):
-        err("pass exactly one of --query or --seeds")
+    # At most one. NEITHER is a paid broad sweep of the whole Blueprint schema
+    # (#1005), which the API accepts; the CLI used to refuse it as a usage
+    # error and could not express the feature at all.
+    if args.query and args.seeds:
+        err("pass at most one of --query or --seeds")
         return EXIT_USAGE
 
     body: dict[str, Any] = {"depth": args.depth, "dry_run": args.dry_run, "monitored": args.monitored}
@@ -322,10 +325,70 @@ def cmd_runs_cancel(args) -> int:
     return EXIT_OK
 
 
+def cmd_members_list(args) -> int:
+    """Who is in this workspace and how many editor seats are in use (#985).
+    Read-only; inviting is a human-admin action in the UI."""
+    client, _ = _require_auth(args)
+    try:
+        body = client.request("GET", "/v1/members")
+    except ApiError as exc:
+        err(str(exc))
+        return EXIT_FAIL
+    if args.json:
+        out(body, True)
+        return EXIT_OK
+    for m in body.get("data", []):
+        print(f"{m.get('email')}  {m.get('role')}  ({m.get('status')})")
+    seats = body.get("seats") or {}
+    inc = seats.get("editor_seats_included")
+    used = seats.get("editor_seats_used")
+    print(f"\neditor seats: {used} used / {'unlimited' if inc is None else inc} included")
+    return EXIT_OK
+
+
+def _blueprint_id(client, args) -> str | None:
+    """The Blueprint these commands address: ``--blueprint``, else the active one.
+
+    `/v1/data` was removed (pre-GA breaking change): every dataset read now names
+    its Blueprint in the path, because a read against the wrong one returns a
+    well-formed dataset about the wrong domain and nothing in the response says
+    so. The CLI keeps its zero-argument form by resolving the active Blueprint
+    here — one extra request, and only when no id was given.
+
+    Returns None after printing the reason, so callers exit non-zero rather than
+    falling back to some other Blueprint.
+    """
+    if getattr(args, "blueprint", None):
+        return args.blueprint
+    try:
+        body = client.request("GET", "/v1/blueprints")
+    except ApiError as exc:
+        err(str(exc))
+        return None
+    rows = body.get("data") or []
+    active = next((r for r in rows if r.get("is_active")), None)
+    if active is None:
+        # Say which of the two states this is. "No Blueprints at all" and "none
+        # of them is active" need different actions from the user, and an
+        # unqualified "not found" would send them looking for the wrong problem.
+        if not rows:
+            err("no Blueprints yet — design one in the app first.")
+        else:
+            err(
+                "no active Blueprint. Pass --blueprint <id>; "
+                "`deepsieve data catalog --blueprint <id>` lists ids via /v1/blueprints."
+            )
+        return None
+    return active.get("id")
+
+
 def cmd_data_catalog(args) -> int:
     client, _ = _require_auth(args)
+    bp_id = _blueprint_id(client, args)
+    if bp_id is None:
+        return EXIT_FAIL
     try:
-        body = client.request("GET", "/v1/data")
+        body = client.request("GET", f"/v1/blueprints/{bp_id}")
     except ApiError as exc:
         err(str(exc))
         return EXIT_FAIL
@@ -340,13 +403,18 @@ def cmd_data_catalog(args) -> int:
 
 def cmd_data_get(args) -> int:
     client, _ = _require_auth(args)
+    bp_id = _blueprint_id(client, args)
+    if bp_id is None:
+        return EXIT_FAIL
     params: dict[str, Any] = {"limit": args.limit, "receipts": args.receipts}
     if args.cursor:
         params["cursor"] = args.cursor
     if args.updated_since:
         params["updated_since"] = args.updated_since
     try:
-        body = client.request("GET", f"/v1/data/{args.entity}", params=params)
+        body = client.request(
+            "GET", f"/v1/blueprints/{bp_id}/entities/{args.entity}", params=params
+        )
     except ApiError as exc:
         err(str(exc))
         return EXIT_FAIL
@@ -484,9 +552,14 @@ def build_parser() -> argparse.ArgumentParser:
     rx.add_argument("run_id")
     rx.set_defaults(func=cmd_runs_cancel)
 
+    members = sub.add_parser("members", help="your workspace's team", parents=[common]).add_subparsers(dest="sub", required=True)
+    ml = members.add_parser("list", help="who is in the workspace, and seat usage", parents=[common])
+    ml.set_defaults(func=cmd_members_list)
+
     data = sub.add_parser("data", help="your cited dataset", parents=[common]).add_subparsers(dest="sub", required=True)
 
     dc = data.add_parser("catalog", help="entities and columns (never guess these)", parents=[common])
+    dc.add_argument("--blueprint", help="Blueprint id (default: the active one)")
     dc.set_defaults(func=cmd_data_catalog)
 
     dg = data.add_parser("get", help="rows for one entity", parents=[common])
@@ -495,6 +568,7 @@ def build_parser() -> argparse.ArgumentParser:
     dg.add_argument("--cursor")
     dg.add_argument("--updated-since")
     dg.add_argument("--receipts", action="store_true", help="include per-cell citations")
+    dg.add_argument("--blueprint", help="Blueprint id (default: the active one)")
     dg.set_defaults(func=cmd_data_get)
 
     setup = sub.add_parser("setup", help="connect other tools", parents=[common]).add_subparsers(

{deepsieve_cli-0.1.0 → deepsieve_cli-0.2.0}/tests/test_cli.py

@@ -207,16 +207,41 @@ def test_dry_run_needs_no_confirmation(monkeypatch):
     assert seen["idem"], "runs cost money — every create must carry an idempotency key"
 
 
-def test_run_create_requires_exactly_one_of_query_or_seeds(monkeypatch, capsys):
+def test_run_create_refuses_both_query_and_seeds(monkeypatch, capsys):
     cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="k"))
-    assert main(["runs", "create"]) == 2
-    assert "exactly one" in capsys.readouterr().err
+    assert main(["runs", "create", "--query", "x", "--seeds", "a,b"]) == 2
+    assert "at most one" in capsys.readouterr().err
+
+
+def test_run_create_with_neither_sends_an_empty_broad_sweep(monkeypatch):
+    """#1005: neither flag is a schema-derived broad sweep, not a usage error.
+    The body must carry NEITHER key — the API treats their absence as the
+    sweep, and a `query: ""` would be a validation error instead."""
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="k"))
+    seen = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen["body"] = json.loads(request.content)
+        return httpx.Response(202, json={"id": "run_1", "status": "queued"})
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["runs", "create", "--dry-run"]) == 0
+    assert "query" not in seen["body"] and "seeds" not in seen["body"]
+    assert seen["body"]["dry_run"] is True
+
+
+# A workspace with one Blueprint, active. `data` commands resolve through this
+# listing since #1282 removed the ambient /v1/data — so a handler that does not
+# serve it is a handler the data commands cannot get past.
+_ONE_ACTIVE_BP = {"data": [{"id": "bp_1", "name": "Finance", "is_active": True}]}
 
 
 def test_truncated_dataset_is_called_out(monkeypatch, capsys):
     cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="k"))
 
-    def handler(_r):
+    def handler(r):
+        if r.url.path == "/v1/blueprints":
+            return httpx.Response(200, json=_ONE_ACTIVE_BP)
         return httpx.Response(200, json={"data": [], "truncated": True, "preview_row_cap": 10})
 
     monkeypatch.setattr(httpx, "Client", _mock(handler))
@@ -224,6 +249,59 @@ def test_truncated_dataset_is_called_out(monkeypatch, capsys):
     assert "PREVIEW" in capsys.readouterr().err
 
 
+def test_data_get_addresses_the_active_blueprint_by_id(monkeypatch):
+    """The path must NAME a Blueprint. #1282 removed the ambient `/v1/data/{key}`,
+    so a CLI still calling it would 404 against any current deployment."""
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="k"))
+    seen = {}
+
+    def handler(r):
+        if r.url.path == "/v1/blueprints":
+            return httpx.Response(200, json=_ONE_ACTIVE_BP)
+        seen["path"] = r.url.path
+        return httpx.Response(200, json={"data": []})
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["data", "get", "companies"]) == 0
+    assert seen["path"] == "/v1/blueprints/bp_1/entities/companies"
+
+
+def test_blueprint_flag_names_one_without_consulting_the_listing(monkeypatch):
+    """`--blueprint` is the whole point of the flag: it must not be second-guessed
+    against the active one, and it must not cost a listing call."""
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="k"))
+    paths = []
+
+    def handler(r):
+        paths.append(r.url.path)
+        return httpx.Response(200, json={"data": []})
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["data", "get", "companies", "--blueprint", "bp_other"]) == 0
+    assert paths == ["/v1/blueprints/bp_other/entities/companies"]
+
+
+def test_no_active_blueprint_fails_rather_than_picking_one(monkeypatch, capsys):
+    """⚠️ The failure mode this helper exists to prevent.
+
+    With several Blueprints and none active, reading "whichever" returns a
+    well-formed dataset about the wrong domain — indistinguishable from the
+    right answer. So it exits NON-ZERO and names the flag, rather than falling
+    back to the first row.
+    """
+    cfg.save_profile(cfg.Profile(name="default", origin="https://x.test", api_key="k"))
+    listed = {"data": [{"id": "a", "is_active": False}, {"id": "b", "is_active": False}]}
+
+    def handler(r):
+        if r.url.path == "/v1/blueprints":
+            return httpx.Response(200, json=listed)
+        raise AssertionError(f"must not read data without a Blueprint: {r.url.path}")
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["data", "get", "companies"]) != 0
+    assert "--blueprint" in capsys.readouterr().err
+
+
 def test_setup_mcp_names_this_profiles_origin(monkeypatch, capsys):
     cfg.save_profile(cfg.Profile(name="staging", origin="https://staging.test", api_key="k"))
     assert main(["--profile", "staging", "setup", "mcp"]) == 0
@@ -354,3 +432,76 @@ def test_failed_run_exits_failure_not_success(monkeypatch):
 
     monkeypatch.setattr(httpx, "Client", _mock(handler))
     assert main(["runs", "get", "r"]) == 1
+
+
+# ── members list (#985) ──────────────────────────────────────────────────────
+
+
+def _members_body(*, included=10, viewers=True):
+    return {
+        "object": "list",
+        "data": [
+            {"object": "member", "id": "m1", "user_id": "u1", "email": "owner@example.com",
+             "role": "owner", "status": "active", "workspace_ids": [], "created_at": None},
+            {"object": "member", "id": "m2", "user_id": "u2", "email": "reader@example.com",
+             "role": "viewer", "status": "active", "workspace_ids": ["ws1"], "created_at": None},
+        ],
+        "has_more": False,
+        "next_cursor": None,
+        "seats": {"editor_seats_used": 1, "editor_seats_included": included,
+                  "editor_seats_free_now": None if included is None else included - 1,
+                  "viewer_seats_available": viewers},
+    }
+
+
+def _signed_in(monkeypatch):
+    monkeypatch.setenv(cfg.ENV_KEY, "ds_live_test")
+    monkeypatch.setenv(cfg.ENV_ORIGIN, "https://ci.test")
+
+
+def test_members_list_prints_the_roster_and_seat_usage(monkeypatch, capsys):
+    """Review of #1022 found `members list` shipped with no test at all. Drives
+    the real command through the real client against a mocked /v1/members."""
+    _signed_in(monkeypatch)
+    seen = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen["path"] = request.url.path
+        seen["auth"] = request.headers.get("authorization")
+        return httpx.Response(200, json=_members_body())
+
+    monkeypatch.setattr(httpx, "Client", _mock(handler))
+    assert main(["members", "list"]) == 0
+    out_ = capsys.readouterr().out
+    assert seen["path"] == "/v1/members"
+    assert seen["auth"] == "Bearer ds_live_test"
+    assert "owner@example.com  owner  (active)" in out_
+    assert "reader@example.com  viewer  (active)" in out_
+    assert "editor seats: 1 used / 10 included" in out_
+
+
+def test_members_list_json_is_the_raw_body_and_unlimited_reads_as_such(monkeypatch, capsys):
+    _signed_in(monkeypatch)
+    body = _members_body(included=None)  # Enterprise: null = unlimited
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: httpx.Response(200, json=body)))
+    assert main(["members", "list", "--json"]) == 0
+    assert json.loads(capsys.readouterr().out) == body
+    # and the human form renders null as "unlimited", never "None". Client is
+    # still patched from above — patching again would wrap the patched factory
+    # and pass `transport` twice (that exact TypeError shipped in a red commit).
+    assert main(["members", "list"]) == 0
+    text = capsys.readouterr().out
+    assert "unlimited included" in text and "None" not in text
+
+
+def test_members_list_surfaces_a_scope_refusal_as_a_typed_error(monkeypatch, capsys):
+    """An `agent`-preset key lacks members:read; the CLI must show the API's
+    code + message and exit non-zero, not stack-trace or print an empty roster."""
+    _signed_in(monkeypatch)
+    err_body = {"error": {"type": "permission_error", "code": "insufficient_scope",
+                          "message": "this key lacks members:read", "retriable": False}}
+    monkeypatch.setattr(httpx, "Client", _mock(lambda r: httpx.Response(403, json=err_body)))
+    assert main(["members", "list"]) == 1
+    captured = capsys.readouterr()
+    assert "insufficient_scope" in captured.err or "members:read" in captured.err
+    assert "owner@example.com" not in captured.out