cmpnd 0.19.0__tar.gz → 0.20.0__tar.gz

{cmpnd-0.19.0 → cmpnd-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cmpnd
-Version: 0.19.0
+Version: 0.20.0
 Summary: DSPy observability and deployment SDK for cmpnd
 Project-URL: Homepage, https://cmpnd.ai
 Author-email: cmpnd <hello@cmpnd.ai>

{cmpnd-0.19.0 → cmpnd-0.20.0}/cmpnd/cli/__init__.py

@@ -13,6 +13,7 @@ import httpx
 from . import api_client, deprecation
 from .commands import (
     admin,
+    assessments,
     auth,
     datasets,
     deployments,
@@ -26,6 +27,7 @@ from .commands import (
     tool_servers,
     top,
     traces,
+    valsets,
 )
 
 
@@ -141,6 +143,15 @@ def main() -> None:
     datasets.register(subparsers)
     deployments.register(subparsers)
 
+    # Assessments and valsets CLIs are still in development, hidden behind
+    # CMPND_CLI_DEV=1 (mirroring the CMPND_CLI_ADMIN gate above). The env var
+    # only hides the commands from customers; the server still gates each action
+    # on the assessments:* / valsets:* scope, so this is discoverability, not
+    # enforcement.
+    if os.environ.get("CMPND_CLI_DEV") == "1":
+        assessments.register(subparsers)
+        valsets.register(subparsers)
+
     # Top-level Docker-style shortcuts (human-readable by default; --json opts in)
     top.register(subparsers)
 

cmpnd-0.20.0/cmpnd/cli/commands/assessments.py

@@ -0,0 +1,67 @@
+"""Assessments commands.
+
+An assessment is a person's judgement of a trace: an up/down/neutral
+conclusion, a prose body, and per-span annotations. See the assessments API.
+"""
+
+from __future__ import annotations
+
+from argparse import ArgumentParser, _SubParsersAction
+from typing import Any
+
+from .. import api_client
+
+
+def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
+    parser = subparsers.add_parser("assessments", help="Record and read judgements of traces")
+    sub = parser.add_subparsers(dest="action")
+
+    create = sub.add_parser("create", help="Record a judgement of a trace")
+    create.add_argument("trace_id", help="The trace to assess (its SDK trace id)")
+    conclusion = create.add_mutually_exclusive_group(required=True)
+    conclusion.add_argument(
+        "--up", dest="conclusion", action="store_const", const="up", help="Affirm the trace's output"
+    )
+    conclusion.add_argument(
+        "--down", dest="conclusion", action="store_const", const="down", help="Dispute the trace's output"
+    )
+    conclusion.add_argument(
+        "--neutral", dest="conclusion", action="store_const", const="neutral", help="Neither affirm nor dispute"
+    )
+    create.add_argument("-m", "--message", dest="body", help="The prose body of the judgement")
+    create.add_argument(
+        "--annotate",
+        dest="annotations",
+        action="append",
+        nargs=2,
+        metavar=("SPAN_ID", "NOTE"),
+        help="Attach a note to one span in the trace (repeat for multiple)",
+    )
+    create.set_defaults(func=handle_create)
+
+    ls = sub.add_parser("list", help="List a program's assessments")
+    ls.add_argument(
+        "--program", required=True, help="Program signature hash (16-hex, as `cmpnd signatures list` shows)"
+    )
+    ls.set_defaults(func=handle_list)
+
+    show = sub.add_parser("show", help="Show one assessment with its annotations")
+    show.add_argument("id", help="Assessment id")
+    show.set_defaults(func=handle_show)
+
+
+def handle_create(client: api_client.ApiClient, args: Any) -> Any:
+    body: dict[str, Any] = {"trace_id": args.trace_id, "conclusion": args.conclusion}
+    if args.body:
+        body["body"] = args.body
+    if args.annotations:
+        body["annotations"] = [{"span_id": span, "note": note} for span, note in args.annotations]
+    return client.post("/api/v1/assessments", json=body)
+
+
+def handle_list(client: api_client.ApiClient, args: Any) -> Any:
+    return client.get("/api/v1/assessments", params={"program": args.program})
+
+
+def handle_show(client: api_client.ApiClient, args: Any) -> Any:
+    return client.get(f"/api/v1/assessments/{args.id}")

cmpnd-0.20.0/cmpnd/cli/commands/valsets.py

@@ -0,0 +1,101 @@
+"""Valsets commands.
+
+A valset is a program-owned validation set: a name, the field shape derived
+from the owning program's signature, and its entries. Entries carry the
+inputs and expected outputs of one validation example.
+"""
+
+from __future__ import annotations
+
+import json
+from argparse import ArgumentParser, _SubParsersAction
+from typing import Any
+
+from .. import api_client
+
+
+def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
+    parser = subparsers.add_parser("valsets", help="Manage program-owned validation sets")
+    sub = parser.add_subparsers(dest="action")
+
+    create = sub.add_parser("create", help="Create a validation set owned by a program")
+    create.add_argument("program_hash", help="Owning program signature hash (16-hex, as `cmpnd signatures list` shows)")
+    create.add_argument("--name", required=True, help="Validation-set name (unique within the program)")
+    create.set_defaults(func=handle_create)
+
+    ls = sub.add_parser("list", help="List a program's validation sets")
+    ls.add_argument("--program", required=True, help="Program signature hash (16-hex)")
+    ls.set_defaults(func=handle_list)
+
+    show = sub.add_parser("show", help="Show a validation set")
+    show.add_argument("id", help="Valset id")
+    show.set_defaults(func=handle_show)
+
+    entries = sub.add_parser("entries", help="Manage a validation set's entries")
+    esub = entries.add_subparsers(dest="entries_action")
+
+    elist = esub.add_parser("list", help="List a valset's active entries")
+    elist.add_argument("valset_id", help="Valset id")
+    elist.set_defaults(func=handle_entries_list)
+
+    ecreate = esub.add_parser("create", help="Add an entry from JSON content")
+    ecreate.add_argument("valset_id", help="Valset id")
+    ecreate.add_argument(
+        "--inputs", required=True, metavar="JSON", help="Inputs object; its keys are the valset's input fields"
+    )
+    ecreate.add_argument(
+        "--expected-outputs",
+        dest="expected_outputs",
+        required=True,
+        metavar="JSON",
+        help="Expected-outputs object; its keys are the valset's output fields",
+    )
+    ecreate.add_argument(
+        "--from-assessment", dest="from_assessment", help="Source assessment id, recorded as the entry's provenance"
+    )
+    ecreate.set_defaults(func=handle_entries_create)
+
+    edelete = esub.add_parser("delete", help="Retire an entry (versioned, not a hard delete)")
+    edelete.add_argument("entry_id", help="Entry id")
+    edelete.set_defaults(func=handle_entries_delete)
+
+
+def handle_create(client: api_client.ApiClient, args: Any) -> Any:
+    return client.post("/api/v1/valsets", json={"program": args.program_hash, "name": args.name})
+
+
+def handle_list(client: api_client.ApiClient, args: Any) -> Any:
+    return client.get("/api/v1/valsets", params={"program": args.program})
+
+
+def handle_show(client: api_client.ApiClient, args: Any) -> Any:
+    return client.get(f"/api/v1/valsets/{args.id}")
+
+
+def handle_entries_list(client: api_client.ApiClient, args: Any) -> Any:
+    return client.get(f"/api/v1/valsets/{args.valset_id}/entries")
+
+
+def handle_entries_create(client: api_client.ApiClient, args: Any) -> Any:
+    inputs = _parse_json_flag("--inputs", args.inputs)
+    expected = _parse_json_flag("--expected-outputs", args.expected_outputs)
+    body: dict[str, Any] = {"inputs": inputs, "expected_outputs": expected}
+    if args.from_assessment:
+        body["from_assessment"] = args.from_assessment
+    return client.post(f"/api/v1/valsets/{args.valset_id}/entries", json=body)
+
+
+def handle_entries_delete(client: api_client.ApiClient, args: Any) -> Any:
+    client.delete(f"/api/v1/valsets/entries/{args.entry_id}")
+    # The route returns 204; echo a confirmation so the CLI does not print null.
+    return {"deleted": args.entry_id}
+
+
+def _parse_json_flag(flag: str, value: str) -> dict[str, Any]:
+    try:
+        parsed = json.loads(value)
+    except json.JSONDecodeError as exc:
+        raise api_client.CliError(f"{flag} JSON is invalid: {exc}") from exc
+    if not isinstance(parsed, dict):
+        raise api_client.CliError(f"{flag} JSON must be an object")
+    return parsed

{cmpnd-0.19.0 → cmpnd-0.20.0}/docs/cli.md

@@ -79,6 +79,27 @@ Every list command paginates with `--limit`/`--offset`. The older
 warn. On the page-number commands `--offset` must be a whole multiple of
 `--limit`; the error names the nearest valid offsets.
 
+## Assessments
+
+`cmpnd assessments` records and reads a person's judgement of a trace: an
+up/down/neutral conclusion, an optional prose body, and per-span annotations.
+
+> **In development — behind `CMPND_CLI_DEV=1`.** The group is registered only
+> when that env var is set (mirroring `CMPND_CLI_ADMIN`), so it stays hidden from
+> `cmpnd --help` until the flow is finished. The env var only hides the commands;
+> the server still gates each action on the `assessments:*` scope.
+
+- `cmpnd assessments create <trace-id> --up|--down|--neutral [-m "prose"] [--annotate <span-id> "note" …]`
+  — record one judgement. Exactly one conclusion flag is required (`--up`
+  affirms the trace's output, `--down` disputes it, `--neutral` does neither);
+  they are mutually exclusive. `-m`/`--message` sets the prose body. `--annotate`
+  takes a span id and a note, and repeats to attach a note to more than one span
+  in the trace.
+- `cmpnd assessments list --program <16-hex-hash>` — the assessments recorded
+  against a program, addressed by its program signature hash in the 16-char hex
+  form `cmpnd signatures list` prints.
+- `cmpnd assessments show <assessment-id>` — one assessment with its annotations.
+
 ## Other query groups
 
 `cmpnd programs`, `cmpnd signatures`, `cmpnd evals`, `cmpnd datasets`,
@@ -99,6 +120,32 @@ found. Each group's `--help` names the column its ids come from.
 `cmpnd deployments openapi <id>` prints the OpenAPI document a deployment
 serves, which is what an agent needs before it can call one.
 
+## Validation sets
+
+`cmpnd valsets` manages a program-owned validation set: a named set of
+validation examples whose field shape comes from the owning program's signature.
+The program hash is the 16-hex signature hash throughout (what `cmpnd signatures
+list` shows). Entries live in a nested `entries` subgroup, the same shape as
+`cmpnd datasets examples`.
+
+> **In development — behind `CMPND_CLI_DEV=1`.** Registered only when that env
+> var is set (mirroring `CMPND_CLI_ADMIN`), so it stays hidden from
+> `cmpnd --help` until the flow is finished. The env var only hides the commands;
+> the server still gates each action on the `valsets:*` scope.
+
+- `cmpnd valsets create <program-hash> --name <name>` — create a validation set
+  owned by a program; the name is unique within that program.
+- `cmpnd valsets list --program <16-hex-hash>` — list a program's validation sets.
+- `cmpnd valsets show <valset-id>` — show one validation set.
+- `cmpnd valsets entries list <valset-id>` — list a valset's active entries.
+- `cmpnd valsets entries create <valset-id> --inputs '{…}' --expected-outputs
+  '{…}' [--from-assessment <id>]` — add an entry. `--inputs` and
+  `--expected-outputs` are JSON objects keyed by the valset's declared input and
+  output fields. `--from-assessment` records a source assessment id as the
+  entry's provenance.
+- `cmpnd valsets entries delete <entry-id>` — retire an entry (versioned, not a
+  hard delete).
+
 ## Credentials
 
 `cmpnd credentials` covers two kinds of key, because both answer the same

{cmpnd-0.19.0 → cmpnd-0.20.0}/pyproject.toml

@@ -5,7 +5,7 @@ name = "cmpnd"
 # it's new) — no git tags. Bump with `uv version --bump {minor,patch}` or by
 # hand. Runtime `cmpnd.__version__` reads installed metadata, so it tracks
 # this automatically. See docs/plans/2026-07-02-sdk-pypi-tag-free-publish.md.
-version = "0.19.0"
+version = "0.20.0"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
 requires-python = ">=3.10"

cmpnd-0.20.0/tests/e2e/test_assessments_cli.py

@@ -0,0 +1,68 @@
+"""End-to-end tests for the `cmpnd assessments` CLI against a live server.
+
+The CLI is an API consumer, so these drive the real command handlers through a
+real ApiClient against a live backend — the level that catches a contract
+mismatch a mocked client cannot (e.g. the program-hash wire format). Skipped
+unless CMPND_E2E_API_KEY is set (see conftest).
+"""
+
+from __future__ import annotations
+
+import argparse
+
+import dspy
+import pytest
+
+from cmpnd.cli import api_client
+from cmpnd.cli.commands import assessments as assessments_cmd
+from tests.e2e.conftest import CMPND_E2E_API_KEY, E2E_ENDPOINT, flush_and_wait
+
+pytestmark = pytest.mark.e2e
+
+
+def _ns(**kw: object) -> argparse.Namespace:
+    return argparse.Namespace(**kw)
+
+
+class TestAssessmentsCliE2E:
+    def test_create_list_show_against_live_api(self, server_client, trace_capture):
+        # Produce a real trace to assess, then read back its program hash + a span.
+        dspy.Predict("question -> answer")(question="Who represents District 4?")
+        flush_and_wait()
+        trace_id = trace_capture.last_trace_id
+        assert trace_id is not None, "no trace captured"
+        data = server_client.get_trace(trace_id)
+        # The trace API returns the hash as a signed int64 (decimal); the
+        # assessments and modules APIs speak the 16-hex display form. Normalize
+        # so the create/list calls and the assertion compare like for like.
+        program_hash = format(int(data["trace"]["program_signature_hash"]) & 0xFFFFFFFFFFFFFFFF, "016x")
+        assert data["spans"], "trace has no spans to annotate"
+        span_id = data["spans"][0]["span_id"]
+
+        client = api_client.ApiClient(CMPND_E2E_API_KEY, E2E_ENDPOINT)
+
+        # create — a down judgement with one span annotation.
+        created = assessments_cmd.handle_create(
+            client,
+            _ns(
+                trace_id=trace_id,
+                conclusion="down",
+                body="the answer names the office, not the representative",
+                annotations=[[span_id, "this predict returned the wrong field"]],
+            ),
+        )
+        assert created["id"].startswith("as_")
+        assert created["conclusion"] == "down"
+        # The program hash the server copied off the trace round-trips as the same
+        # 16-hex string the trace read returned — the CLI passes it through verbatim.
+        assert created["program_signature_hash"] == program_hash
+        assert created["annotations"][0]["span_id"] == span_id
+
+        # list by program (the 16-hex form) finds the assessment we just created.
+        listed = assessments_cmd.handle_list(client, _ns(program=program_hash))
+        assert created["id"] in [a["id"] for a in listed["assessments"]]
+
+        # show round-trips the body and the annotation note.
+        shown = assessments_cmd.handle_show(client, _ns(id=created["id"]))
+        assert shown["id"] == created["id"]
+        assert shown["annotations"][0]["note"] == "this predict returned the wrong field"

cmpnd-0.20.0/tests/e2e/test_valsets_cli.py

@@ -0,0 +1,102 @@
+"""End-to-end tests for the `cmpnd valsets` CLI against a live server.
+
+Drives the real command handlers through a real ApiClient against a live
+backend — the level that catches a CLI↔API contract mismatch a mocked client
+cannot. Skipped unless CMPND_E2E_API_KEY is set (see conftest).
+"""
+
+from __future__ import annotations
+
+import argparse
+import uuid
+
+import dspy
+import pytest
+
+from cmpnd.cli import api_client
+from cmpnd.cli.commands import assessments as assessments_cmd
+from cmpnd.cli.commands import valsets as valsets_cmd
+from tests.e2e.conftest import CMPND_E2E_API_KEY, E2E_ENDPOINT, flush_and_wait
+
+pytestmark = pytest.mark.e2e
+
+
+def _ns(**kw: object) -> argparse.Namespace:
+    return argparse.Namespace(**kw)
+
+
+def _program_and_trace(server_client, trace_capture) -> tuple[str, str, str]:
+    """Run a program, return (program_hash, trace_id, first span id)."""
+    dspy.Predict("question -> answer")(question="Who represents District 4?")
+    flush_and_wait()
+    trace_id = trace_capture.last_trace_id
+    assert trace_id is not None, "no trace captured"
+    data = server_client.get_trace(trace_id)
+    # The trace API returns the hash as a signed int64 (decimal); the valsets
+    # and modules APIs speak the 16-hex display form, so normalize before the
+    # create/list calls that carry it.
+    program_hash = format(int(data["trace"]["program_signature_hash"]) & 0xFFFFFFFFFFFFFFFF, "016x")
+    return program_hash, trace_id, data["spans"][0]["span_id"]
+
+
+class TestValsetsCliE2E:
+    def test_valset_and_entry_lifecycle(self, server_client, trace_capture):
+        program_hash, _trace_id, _span = _program_and_trace(server_client, trace_capture)
+        client = api_client.ApiClient(CMPND_E2E_API_KEY, E2E_ENDPOINT)
+
+        # create derives the field shape from the owning program.
+        vs = valsets_cmd.handle_create(client, _ns(program_hash=program_hash, name=f"e2e gold {uuid.uuid4().hex[:8]}"))
+        assert vs["id"].startswith("vs_")
+        assert vs["program_signature_hash"] == program_hash
+        assert vs["input_fields"] == ["question"]
+
+        # list by program finds it; show returns the header.
+        listed = valsets_cmd.handle_list(client, _ns(program=program_hash))
+        assert vs["id"] in [v["id"] for v in listed["valsets"]]
+        assert valsets_cmd.handle_show(client, _ns(id=vs["id"]))["id"] == vs["id"]
+
+        # entries create — a manual entry matching the field shape.
+        entry = valsets_cmd.handle_entries_create(
+            client,
+            _ns(
+                valset_id=vs["id"],
+                inputs='{"question": "Who represents District 4?"}',
+                expected_outputs='{"answer": "Rep. Alice Nguyen"}',
+                from_assessment=None,
+            ),
+        )
+        assert entry["id"].startswith("ve_")
+        assert entry["origin"] == "manual"
+
+        # entries list shows it; entries delete retires it (versioned).
+        assert entry["id"] in [
+            e["id"] for e in valsets_cmd.handle_entries_list(client, _ns(valset_id=vs["id"]))["entries"]
+        ]
+        assert valsets_cmd.handle_entries_delete(client, _ns(entry_id=entry["id"])) == {"deleted": entry["id"]}
+        assert entry["id"] not in [
+            e["id"] for e in valsets_cmd.handle_entries_list(client, _ns(valset_id=vs["id"]))["entries"]
+        ]
+
+    def test_entry_from_assessment(self, server_client, trace_capture):
+        program_hash, trace_id, span_id = _program_and_trace(server_client, trace_capture)
+        client = api_client.ApiClient(CMPND_E2E_API_KEY, E2E_ENDPOINT)
+
+        # An assessment of the trace, then an entry created from it.
+        assessment = assessments_cmd.handle_create(
+            client,
+            _ns(trace_id=trace_id, conclusion="down", body="corrected", annotations=[[span_id, "wrong field"]]),
+        )
+        vs = valsets_cmd.handle_create(
+            client, _ns(program_hash=program_hash, name=f"e2e from-assessment {uuid.uuid4().hex[:8]}")
+        )
+        entry = valsets_cmd.handle_entries_create(
+            client,
+            _ns(
+                valset_id=vs["id"],
+                inputs='{"question": "Who represents District 4?"}',
+                expected_outputs='{"answer": "Rep. Alice Nguyen"}',
+                from_assessment=assessment["id"],
+            ),
+        )
+        assert entry["origin"] == "assessment"
+        assert entry["source_assessment_id"] == assessment["id"]

cmpnd-0.20.0/tests/test_cli/test_assessments.py

@@ -0,0 +1,84 @@
+"""Tests for cmpnd.cli.commands.assessments."""
+
+from __future__ import annotations
+
+import argparse
+
+from cmpnd.cli.commands import assessments as assessments_cmd
+from cmpnd.cli.commands.assessments import handle_create, handle_list, handle_show
+
+
+class TestAssessmentsCreate:
+    def test_minimal_up_judgement(self, mock_client):
+        mock_client.post.return_value = {"id": "as_1"}
+        args = argparse.Namespace(trace_id="t-1", conclusion="up", body=None, annotations=None)
+        handle_create(mock_client, args)
+        mock_client.post.assert_called_once_with("/api/v1/assessments", json={"trace_id": "t-1", "conclusion": "up"})
+
+    def test_body_and_repeatable_annotations_assemble_the_array(self, mock_client):
+        mock_client.post.return_value = {"id": "as_1"}
+        args = argparse.Namespace(
+            trace_id="t-1",
+            conclusion="down",
+            body="the office is wrong",
+            annotations=[["span-a", "dropped the district"], ["span-b", "mislabeled it"]],
+        )
+        handle_create(mock_client, args)
+        mock_client.post.assert_called_once_with(
+            "/api/v1/assessments",
+            json={
+                "trace_id": "t-1",
+                "conclusion": "down",
+                "body": "the office is wrong",
+                "annotations": [
+                    {"span_id": "span-a", "note": "dropped the district"},
+                    {"span_id": "span-b", "note": "mislabeled it"},
+                ],
+            },
+        )
+
+
+class TestAssessmentsList:
+    def test_passes_program_through(self, mock_client):
+        mock_client.get.return_value = {"assessments": [], "total": 0}
+        args = argparse.Namespace(program="08729442d1b3a3bf")
+        handle_list(mock_client, args)
+        mock_client.get.assert_called_once_with("/api/v1/assessments", params={"program": "08729442d1b3a3bf"})
+
+
+class TestAssessmentsShow:
+    def test_show_by_id(self, mock_client):
+        mock_client.get.return_value = {"id": "as_9"}
+        args = argparse.Namespace(id="as_9")
+        handle_show(mock_client, args)
+        mock_client.get.assert_called_once_with("/api/v1/assessments/as_9")
+
+
+class TestAssessmentsRegistration:
+    def test_subcommands_register(self):
+        import argparse as ap
+
+        parser = ap.ArgumentParser()
+        sub = parser.add_subparsers(dest="resource")
+        assessments_cmd.register(sub)
+        group = sub.choices["assessments"]
+        actions = group._subparsers._group_actions[0].choices  # type: ignore[union-attr]
+        assert set(actions) == {"create", "list", "show"}
+
+    def test_conclusion_is_required(self):
+        import argparse as ap
+
+        parser = ap.ArgumentParser()
+        sub = parser.add_subparsers(dest="resource")
+        assessments_cmd.register(sub)
+        # A create with no conclusion flag is rejected by the mutually-exclusive group.
+        import contextlib
+        import io
+
+        with contextlib.redirect_stderr(io.StringIO()):
+            try:
+                parser.parse_args(["assessments", "create", "t-1"])
+            except SystemExit as exc:
+                assert exc.code == 2
+            else:
+                raise AssertionError("expected create without a conclusion to exit 2")

cmpnd-0.20.0/tests/test_cli/test_valsets.py

@@ -0,0 +1,122 @@
+"""Tests for cmpnd.cli.commands.valsets."""
+
+from __future__ import annotations
+
+import argparse
+
+import pytest
+
+from cmpnd.cli.api_client import CliError
+from cmpnd.cli.commands import valsets as valsets_cmd
+from cmpnd.cli.commands.valsets import (
+    handle_create,
+    handle_entries_create,
+    handle_entries_delete,
+    handle_entries_list,
+    handle_list,
+    handle_show,
+)
+
+
+class TestValsetsCreate:
+    def test_sends_program_and_name(self, mock_client):
+        mock_client.post.return_value = {"id": "vs_1"}
+        args = argparse.Namespace(program_hash="08729442d1b3a3bf", name="gold")
+        handle_create(mock_client, args)
+        mock_client.post.assert_called_once_with(
+            "/api/v1/valsets", json={"program": "08729442d1b3a3bf", "name": "gold"}
+        )
+
+
+class TestValsetsList:
+    def test_passes_program_through(self, mock_client):
+        mock_client.get.return_value = {"valsets": [], "total": 0}
+        handle_list(mock_client, argparse.Namespace(program="08729442d1b3a3bf"))
+        mock_client.get.assert_called_once_with("/api/v1/valsets", params={"program": "08729442d1b3a3bf"})
+
+
+class TestValsetsShow:
+    def test_show_by_id(self, mock_client):
+        mock_client.get.return_value = {"id": "vs_9"}
+        handle_show(mock_client, argparse.Namespace(id="vs_9"))
+        mock_client.get.assert_called_once_with("/api/v1/valsets/vs_9")
+
+
+class TestValsetsEntries:
+    def test_entries_list(self, mock_client):
+        mock_client.get.return_value = {"entries": [], "total": 0}
+        handle_entries_list(mock_client, argparse.Namespace(valset_id="vs_1"))
+        mock_client.get.assert_called_once_with("/api/v1/valsets/vs_1/entries")
+
+    def test_entries_create_parses_json_and_omits_absent_source(self, mock_client):
+        mock_client.post.return_value = {"id": "ve_1"}
+        args = argparse.Namespace(
+            valset_id="vs_1",
+            inputs='{"question": "who?"}',
+            expected_outputs='{"answer": "them"}',
+            from_assessment=None,
+        )
+        handle_entries_create(mock_client, args)
+        mock_client.post.assert_called_once_with(
+            "/api/v1/valsets/vs_1/entries",
+            json={"inputs": {"question": "who?"}, "expected_outputs": {"answer": "them"}},
+        )
+
+    def test_entries_create_includes_source_assessment(self, mock_client):
+        mock_client.post.return_value = {"id": "ve_1"}
+        args = argparse.Namespace(
+            valset_id="vs_1",
+            inputs='{"question": "who?"}',
+            expected_outputs='{"answer": "them"}',
+            from_assessment="as_9",
+        )
+        handle_entries_create(mock_client, args)
+        mock_client.post.assert_called_once_with(
+            "/api/v1/valsets/vs_1/entries",
+            json={
+                "inputs": {"question": "who?"},
+                "expected_outputs": {"answer": "them"},
+                "from_assessment": "as_9",
+            },
+        )
+
+    def test_entries_create_rejects_bad_json(self, mock_client):
+        args = argparse.Namespace(valset_id="vs_1", inputs="{not json", expected_outputs="{}", from_assessment=None)
+        with pytest.raises(CliError, match="--inputs JSON is invalid"):
+            handle_entries_create(mock_client, args)
+        mock_client.post.assert_not_called()
+
+    @pytest.mark.parametrize("value", ["[]", "42", "null", '"text"'])
+    def test_entries_create_rejects_non_object_json(self, mock_client, value):
+        args = argparse.Namespace(
+            valset_id="vs_1", inputs=value, expected_outputs='{"answer": "them"}', from_assessment=None
+        )
+        with pytest.raises(CliError, match="--inputs JSON must be an object"):
+            handle_entries_create(mock_client, args)
+        mock_client.post.assert_not_called()
+
+    def test_entries_create_rejects_non_object_expected_outputs(self, mock_client):
+        args = argparse.Namespace(
+            valset_id="vs_1", inputs='{"question": "who?"}', expected_outputs="[]", from_assessment=None
+        )
+        with pytest.raises(CliError, match="--expected-outputs JSON must be an object"):
+            handle_entries_create(mock_client, args)
+        mock_client.post.assert_not_called()
+
+    def test_entries_delete_confirms(self, mock_client):
+        mock_client.delete.return_value = None
+        result = handle_entries_delete(mock_client, argparse.Namespace(entry_id="ve_1"))
+        mock_client.delete.assert_called_once_with("/api/v1/valsets/entries/ve_1")
+        assert result == {"deleted": "ve_1"}
+
+
+class TestValsetsRegistration:
+    def test_subcommands_register(self):
+        parser = argparse.ArgumentParser()
+        sub = parser.add_subparsers(dest="resource")
+        valsets_cmd.register(sub)
+        group = sub.choices["valsets"]
+        actions = group._subparsers._group_actions[0].choices  # type: ignore[union-attr]
+        assert set(actions) == {"create", "list", "show", "entries"}
+        entries = actions["entries"]._subparsers._group_actions[0].choices  # type: ignore[union-attr]
+        assert set(entries) == {"list", "create", "delete"}

{cmpnd-0.19.0 → cmpnd-0.20.0}/uv.lock

@@ -496,7 +496,7 @@ wheels = [
 
 [[package]]
 name = "cmpnd"
-version = "0.19.0"
+version = "0.20.0"
 source = { editable = "." }
 dependencies = [
     { name = "dspy" },