4lt7ab-grimoire-cli 0.0.1__tar.gz

4lt7ab_grimoire_cli-0.0.1/.gitignore

@@ -0,0 +1,15 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.venv/
+build/
+dist/
+.DS_Store
+.idea/
+.vscode/
+*.swp
+*.db
+.grimoire/
+.local/

4lt7ab_grimoire_cli-0.0.1/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: 4lt7ab-grimoire-cli
+Version: 0.0.1
+Summary: CLI for managing a grimoire datastore
+Requires-Python: >=3.14
+Requires-Dist: 4lt7ab-grimoire
+Requires-Dist: typer>=0.12
+Provides-Extra: fastembed
+Requires-Dist: 4lt7ab-grimoire[fastembed]; extra == 'fastembed'

4lt7ab_grimoire_cli-0.0.1/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "4lt7ab-grimoire-cli"
+version = "0.0.1"
+description = "CLI for managing a grimoire datastore"
+requires-python = ">=3.14"
+dependencies = ["4lt7ab-grimoire", "typer>=0.12"]
+
+[project.optional-dependencies]
+fastembed = ["4lt7ab-grimoire[fastembed]"]
+
+[project.scripts]
+grimoire = "grimoire_cli.main:main"
+
+[tool.uv.sources]
+4lt7ab-grimoire = { workspace = true }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/grimoire_cli"]

4lt7ab_grimoire_cli-0.0.1/src/grimoire_cli/errors.py

@@ -0,0 +1,2 @@
+class GrimoireCliError(Exception):
+    """Base exception for grimoire CLI errors."""

4lt7ab_grimoire_cli-0.0.1/src/grimoire_cli/main.py

@@ -0,0 +1,372 @@
+import json
+from pathlib import Path
+from typing import Annotated, NoReturn
+
+import typer
+from grimoire import Entry, Grimoire, GrimoireError
+
+RECOGNIZED_FIELDS = {"kind", "content", "payload", "threshold"}
+REQUIRED_FIELDS = {"kind", "content"}
+PROGRESS_EVERY = 1000
+DEFAULT_MODEL = "BAAI/bge-small-en-v1.5"
+
+app = typer.Typer(
+    name="grimoire",
+    no_args_is_help=True,
+    pretty_exceptions_enable=False,
+)
+
+
+@app.callback()
+def _callback() -> None:
+    """Manage a grimoire datastore."""
+
+
+@app.command()
+def ingest(
+    file: Annotated[
+        Path,
+        typer.Argument(
+            help="Path to a JSONL file. One JSON object per line.",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+        ),
+    ],
+    db: Annotated[
+        Path,
+        typer.Option(
+            help="Path to the grimoire SQLite file.",
+            envvar="GRIMOIRE_DB",
+        ),
+    ],
+    cache_folder: Annotated[
+        Path,
+        typer.Option(
+            "--cache-folder",
+            help="Directory for the embedder's model cache.",
+            envvar="GRIMOIRE_CACHE",
+        ),
+    ],
+    model: Annotated[
+        str,
+        typer.Option(
+            help=("fastembed model name (only used when creating a new file).")
+        ),
+    ] = DEFAULT_MODEL,
+) -> None:
+    """Bulk-ingest records into a grimoire."""
+    records = _load_records(file)
+    if not records:
+        typer.echo(f"No records to ingest from {file}")
+        return
+
+    with _open_grimoire(db, cache_folder, model_override=model) as g:
+        for i, record in enumerate(records, 1):
+            g.add(
+                kind=record["kind"],
+                content=record["content"],
+                payload=record.get("payload"),
+                threshold=record.get("threshold"),
+            )
+            if i % PROGRESS_EVERY == 0:
+                typer.echo(f"  ingested {i}...", err=True)
+
+    typer.echo(f"Ingested {len(records)} records into {db}")
+
+
+@app.command()
+def search(
+    query: Annotated[str, typer.Argument(help="Query text to embed and search for.")],
+    db: Annotated[
+        Path,
+        typer.Option(
+            help="Path to the grimoire SQLite file.",
+            envvar="GRIMOIRE_DB",
+            exists=True,
+        ),
+    ],
+    cache_folder: Annotated[
+        Path,
+        typer.Option(
+            "--cache-folder",
+            help="Directory for the embedder's model cache.",
+            envvar="GRIMOIRE_CACHE",
+        ),
+    ],
+    kind: Annotated[
+        str | None, typer.Option(help="Restrict results to entries of this kind.")
+    ] = None,
+    k: Annotated[int, typer.Option(help="Number of results to return.")] = 10,
+    dynamic_threshold: Annotated[
+        bool,
+        typer.Option(
+            "--dynamic-threshold",
+            help="Filter results by each entry's stored similarity threshold.",
+        ),
+    ] = False,
+) -> None:
+    """Run a semantic search against a grimoire."""
+    with _open_grimoire(db, cache_folder) as g:
+        for entry in g.search(
+            query, kind=kind, k=k, dynamic_threshold=dynamic_threshold
+        ):
+            _print_entry(entry)
+
+
+@app.command()
+def add(
+    content: Annotated[str, typer.Argument(help="Content text for the new entry.")],
+    db: Annotated[
+        Path,
+        typer.Option(
+            help="Path to the grimoire SQLite file.",
+            envvar="GRIMOIRE_DB",
+        ),
+    ],
+    cache_folder: Annotated[
+        Path,
+        typer.Option(
+            "--cache-folder",
+            help="Directory for the embedder's model cache.",
+            envvar="GRIMOIRE_CACHE",
+        ),
+    ],
+    kind: Annotated[str, typer.Option(help="Kind label for the entry.")] = "note",
+    payload: Annotated[
+        str | None,
+        typer.Option(help="Optional JSON object to attach as the entry payload."),
+    ] = None,
+    threshold: Annotated[
+        float | None,
+        typer.Option(help="Optional per-entry similarity threshold."),
+    ] = None,
+    model: Annotated[
+        str,
+        typer.Option(help="fastembed model name (only used when creating a new file)."),
+    ] = DEFAULT_MODEL,
+) -> None:
+    """Add a single record to a grimoire."""
+    payload_obj: dict | None = None
+    if payload is not None:
+        try:
+            parsed = json.loads(payload)
+        except json.JSONDecodeError as exc:
+            _fail(f"--payload is not valid JSON: {exc.msg}")
+        if not isinstance(parsed, dict):
+            _fail("--payload must be a JSON object")
+        payload_obj = parsed
+    with _open_grimoire(db, cache_folder, model_override=model) as g:
+        entry = g.add(
+            kind=kind,
+            content=content,
+            payload=payload_obj,
+            threshold=threshold,
+        )
+    _print_entry(entry)
+
+
+@app.command()
+def info(
+    db: Annotated[
+        Path,
+        typer.Option(
+            help="Path to the grimoire SQLite file.",
+            envvar="GRIMOIRE_DB",
+        ),
+    ],
+) -> None:
+    """Show metadata and counts for a grimoire file."""
+    stats = Grimoire.peek(db)
+    if stats is None:
+        _fail(f"No grimoire at {db}")
+    typer.echo(
+        json.dumps(
+            {
+                "path": str(db),
+                "model": stats.model,
+                "dimension": stats.dimension,
+                "schema_version": stats.schema_version,
+                "entry_count": stats.entry_count,
+                "kinds": stats.kinds,
+            }
+        )
+    )
+
+
+@app.command(name="list")
+def list_entries(
+    db: Annotated[
+        Path,
+        typer.Option(
+            help="Path to the grimoire SQLite file.",
+            envvar="GRIMOIRE_DB",
+            exists=True,
+        ),
+    ],
+    cache_folder: Annotated[
+        Path,
+        typer.Option(
+            "--cache-folder",
+            help="Directory for the embedder's model cache.",
+            envvar="GRIMOIRE_CACHE",
+        ),
+    ],
+    kind: Annotated[
+        str | None, typer.Option(help="Restrict to entries of this kind.")
+    ] = None,
+    limit: Annotated[
+        int, typer.Option(help="Maximum number of entries to return.")
+    ] = 100,
+    after_id: Annotated[
+        str | None, typer.Option(help="Cursor: return entries with id > this value.")
+    ] = None,
+) -> None:
+    """Paginate entries in chronological order (by id)."""
+    with _open_grimoire(db, cache_folder) as g:
+        for entry in g.list(kind=kind, limit=limit, after_id=after_id):
+            _print_entry(entry)
+
+
+@app.command()
+def get(
+    entry_id: Annotated[str, typer.Argument(help="Entry id (ULID).")],
+    db: Annotated[
+        Path,
+        typer.Option(
+            help="Path to the grimoire SQLite file.",
+            envvar="GRIMOIRE_DB",
+            exists=True,
+        ),
+    ],
+    cache_folder: Annotated[
+        Path,
+        typer.Option(
+            "--cache-folder",
+            help="Directory for the embedder's model cache.",
+            envvar="GRIMOIRE_CACHE",
+        ),
+    ],
+) -> None:
+    """Fetch a single entry by id."""
+    with _open_grimoire(db, cache_folder) as g:
+        entry = g.get(entry_id)
+        if entry is None:
+            _fail(f"No entry with id {entry_id!r}")
+        _print_entry(entry)
+
+
+@app.command()
+def delete(
+    entry_id: Annotated[str, typer.Argument(help="Entry id (ULID).")],
+    db: Annotated[
+        Path,
+        typer.Option(
+            help="Path to the grimoire SQLite file.",
+            envvar="GRIMOIRE_DB",
+            exists=True,
+        ),
+    ],
+    cache_folder: Annotated[
+        Path,
+        typer.Option(
+            "--cache-folder",
+            help="Directory for the embedder's model cache.",
+            envvar="GRIMOIRE_CACHE",
+        ),
+    ],
+) -> None:
+    """Delete an entry by id."""
+    with _open_grimoire(db, cache_folder) as g:
+        if not g.delete(entry_id):
+            _fail(f"No entry with id {entry_id!r}")
+    typer.echo(f"Deleted {entry_id}")
+
+
+def _open_grimoire(
+    db: Path, cache_folder: Path, *, model_override: str | None = None
+) -> Grimoire:
+    """Open a Grimoire, auto-detecting the embedding model from the file when possible.
+
+    Resolution order:
+      1. Model name stored in the file (if file exists and is initialized).
+      2. `model_override` argument (typically a CLI --model flag).
+      3. The library default model.
+    """
+    db.parent.mkdir(parents=True, exist_ok=True)
+    cache_folder.mkdir(parents=True, exist_ok=True)
+    stats = Grimoire.peek(db)
+    model_name = stats.model if stats else (model_override or DEFAULT_MODEL)
+    try:
+        from grimoire.embedders import FastembedEmbedder
+
+        embedder = FastembedEmbedder(model_name, cache_folder=cache_folder)
+    except ImportError as exc:
+        _fail(str(exc))
+    try:
+        return Grimoire.open(db, embedder=embedder)
+    except GrimoireError as exc:
+        _fail(str(exc))
+
+
+def _load_records(path: Path) -> list[dict]:
+    records: list[dict] = []
+    with path.open() as f:
+        for line_no, raw in enumerate(f, 1):
+            line = raw.strip()
+            if not line:
+                continue
+            try:
+                record = json.loads(line)
+            except json.JSONDecodeError as exc:
+                _fail(f"{path}:{line_no}: invalid JSON: {exc.msg}")
+            _validate_record(record, path, line_no)
+            records.append(record)
+    return records
+
+
+def _validate_record(record: object, path: Path, line_no: int) -> None:
+    if not isinstance(record, dict):
+        _fail(f"{path}:{line_no}: record must be a JSON object")
+    missing = REQUIRED_FIELDS - record.keys()
+    if missing:
+        _fail(f"{path}:{line_no}: missing required fields: {sorted(missing)}")
+    unknown = record.keys() - RECOGNIZED_FIELDS
+    if unknown:
+        _fail(
+            f"{path}:{line_no}: unknown fields {sorted(unknown)}. "
+            f"Put extra metadata in `payload`."
+        )
+
+
+def _print_entry(entry: Entry) -> None:
+    record: dict[str, object] = {
+        "id": entry.id,
+        "kind": entry.kind,
+        "content": entry.content,
+    }
+    if entry.payload is not None:
+        try:
+            record["payload"] = json.loads(entry.payload)
+        except json.JSONDecodeError:
+            record["payload"] = entry.payload
+    if entry.threshold is not None:
+        record["threshold"] = entry.threshold
+    if entry.distance is not None:
+        record["distance"] = entry.distance
+    typer.echo(json.dumps(record))
+
+
+def _fail(message: str) -> NoReturn:
+    typer.echo(f"Error: {message}", err=True)
+    raise typer.Exit(code=1)
+
+
+def main() -> None:
+    """Console-script entrypoint for the `grimoire` CLI."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

4lt7ab_grimoire_cli-0.0.1/tests/test_smoke.py

@@ -0,0 +1,376 @@
+import json
+
+import pytest
+from grimoire_cli.main import app
+from typer.testing import CliRunner
+
+runner = CliRunner()
+
+
+@pytest.fixture(scope="session")
+def _grimoire_cache_dir(tmp_path_factory):
+    """A session-shared cache so the embedder model downloads once across tests."""
+    return tmp_path_factory.mktemp("grimoire-cache")
+
+
+@pytest.fixture(autouse=True)
+def _set_grimoire_cache(monkeypatch, _grimoire_cache_dir):
+    monkeypatch.setenv("GRIMOIRE_CACHE", str(_grimoire_cache_dir))
+
+
+# ---------- help / no-args ----------
+
+
+def test_help_lists_all_commands():
+    result = runner.invoke(app, ["--help"])
+    assert result.exit_code == 0
+    for cmd in ("ingest", "search", "list", "get", "delete", "add", "info"):
+        assert cmd in result.output
+
+
+def test_no_args_shows_help():
+    # Click convention: missing subcommand exits 2, but help is still shown.
+    result = runner.invoke(app, [])
+    assert "ingest" in result.output
+
+
+# ---------- ingest ----------
+
+
+def test_ingest_help_describes_options():
+    result = runner.invoke(app, ["ingest", "--help"])
+    assert result.exit_code == 0
+    assert "--db" in result.output
+    assert "--model" in result.output
+
+
+def test_ingest_missing_file_fails(tmp_path):
+    db = tmp_path / "store.db"
+    result = runner.invoke(
+        app, ["ingest", str(tmp_path / "nope.jsonl"), "--db", str(db)]
+    )
+    assert result.exit_code != 0
+
+
+def test_ingest_rejects_invalid_json(tmp_path):
+    db = tmp_path / "store.db"
+    data = tmp_path / "bad.jsonl"
+    data.write_text("not valid json\n")
+    result = runner.invoke(app, ["ingest", str(data), "--db", str(db)])
+    assert result.exit_code == 1
+    assert "invalid JSON" in result.output
+
+
+def test_ingest_rejects_missing_required_field(tmp_path):
+    db = tmp_path / "store.db"
+    data = tmp_path / "missing.jsonl"
+    data.write_text(json.dumps({"content": "no kind"}) + "\n")
+    result = runner.invoke(app, ["ingest", str(data), "--db", str(db)])
+    assert result.exit_code == 1
+    assert "missing required fields" in result.output
+    assert "'kind'" in result.output
+
+
+def test_ingest_rejects_unknown_field(tmp_path):
+    db = tmp_path / "store.db"
+    data = tmp_path / "extra.jsonl"
+    data.write_text(
+        json.dumps({"kind": "note", "content": "x", "extra": "stuff"}) + "\n"
+    )
+    result = runner.invoke(app, ["ingest", str(data), "--db", str(db)])
+    assert result.exit_code == 1
+    assert "unknown fields" in result.output
+
+
+def test_ingest_empty_file_succeeds(tmp_path):
+    db = tmp_path / "store.db"
+    data = tmp_path / "empty.jsonl"
+    data.write_text("")
+    result = runner.invoke(app, ["ingest", str(data), "--db", str(db)])
+    assert result.exit_code == 0
+    assert "No records" in result.output
+
+
+# ---------- read-side commands: missing-file rejection (no ST needed) ----------
+
+
+@pytest.mark.parametrize(
+    "cmd_args",
+    [
+        ["search", "query"],
+        ["list"],
+        ["get", "01HXXXXXXXXXXXXXXXXXXXXXXX"],
+        ["delete", "01HXXXXXXXXXXXXXXXXXXXXXXX"],
+        ["info"],
+    ],
+)
+def test_command_rejects_missing_db(tmp_path, cmd_args):
+    result = runner.invoke(app, [*cmd_args, "--db", str(tmp_path / "nope.db")])
+    assert result.exit_code != 0
+
+
+@pytest.mark.parametrize("cmd", ["search", "list", "get", "delete", "add", "info"])
+def test_command_help_describes_db_option(cmd):
+    result = runner.invoke(app, [cmd, "--help"])
+    assert result.exit_code == 0
+    assert "--db" in result.output
+    assert "GRIMOIRE_DB" in result.output
+
+
+@pytest.mark.parametrize("cmd", ["search", "list", "get", "delete", "add", "ingest"])
+def test_command_help_describes_cache_folder(cmd):
+    result = runner.invoke(app, [cmd, "--help"])
+    assert result.exit_code == 0
+    assert "--cache-folder" in result.output
+    assert "GRIMOIRE_CACHE" in result.output
+
+
+@pytest.mark.parametrize(
+    "cmd_args",
+    [
+        ["info"],
+        ["list"],
+        ["search", "query"],
+        ["get", "01HXXXXXXXXXXXXXXXXXXXXXXX"],
+        ["delete", "01HXXXXXXXXXXXXXXXXXXXXXXX"],
+    ],
+)
+def test_command_requires_db_when_envvar_unset(monkeypatch, cmd_args):
+    monkeypatch.delenv("GRIMOIRE_DB", raising=False)
+    result = runner.invoke(app, cmd_args)
+    assert result.exit_code != 0
+    assert "GRIMOIRE_DB" in result.output
+
+
+def test_command_requires_cache_folder_when_envvar_unset(monkeypatch, tmp_path):
+    monkeypatch.delenv("GRIMOIRE_CACHE", raising=False)
+    monkeypatch.setenv("GRIMOIRE_DB", str(tmp_path / "store.db"))
+    result = runner.invoke(app, ["add", "hello"])
+    assert result.exit_code != 0
+    assert "GRIMOIRE_CACHE" in result.output
+
+
+def test_envvar_supplies_db_path(monkeypatch, tmp_path):
+    monkeypatch.setenv("GRIMOIRE_DB", str(tmp_path / "missing.db"))
+    result = runner.invoke(app, ["info"])
+    assert result.exit_code == 1
+    assert "No grimoire at" in result.output
+
+
+# ---------- end-to-end (gated on fastembed) ----------
+
+
+@pytest.fixture
+def populated_db(tmp_path):
+    pytest.importorskip("fastembed")
+
+    db = tmp_path / "store.db"
+    data = tmp_path / "records.jsonl"
+    data.write_text(
+        json.dumps({"kind": "note", "content": "the moon is full"})
+        + "\n"
+        + json.dumps({"kind": "note", "content": "dragons fly at midnight"})
+        + "\n"
+    )
+    result = runner.invoke(app, ["ingest", str(data), "--db", str(db)])
+    assert result.exit_code == 0
+    return db
+
+
+def test_list_outputs_jsonl(populated_db):
+    result = runner.invoke(app, ["list", "--db", str(populated_db)])
+    assert result.exit_code == 0
+    lines = [line for line in result.output.splitlines() if line.strip()]
+    assert len(lines) == 2
+    parsed = [json.loads(line) for line in lines]
+    assert {p["content"] for p in parsed} == {
+        "the moon is full",
+        "dragons fly at midnight",
+    }
+
+
+def test_search_returns_relevant_entry_first(populated_db):
+    result = runner.invoke(
+        app, ["search", "the moon is full", "--db", str(populated_db), "--k", "2"]
+    )
+    assert result.exit_code == 0
+    lines = [line for line in result.output.splitlines() if line.strip()]
+    parsed = [json.loads(line) for line in lines]
+    assert parsed[0]["content"] == "the moon is full"
+    assert "distance" in parsed[0]
+
+
+def test_get_fetches_by_id(populated_db):
+    list_result = runner.invoke(
+        app, ["list", "--db", str(populated_db), "--limit", "1"]
+    )
+    first = json.loads(list_result.output.strip())
+
+    get_result = runner.invoke(app, ["get", first["id"], "--db", str(populated_db)])
+    assert get_result.exit_code == 0
+    assert json.loads(get_result.output.strip())["id"] == first["id"]
+
+
+def test_get_missing_id_fails(populated_db):
+    result = runner.invoke(
+        app, ["get", "01HXXXXXXXXXXXXXXXXXXXXXXX", "--db", str(populated_db)]
+    )
+    assert result.exit_code == 1
+    assert "No entry" in result.output
+
+
+def test_delete_removes_entry(populated_db):
+    list_result = runner.invoke(
+        app, ["list", "--db", str(populated_db), "--limit", "1"]
+    )
+    first = json.loads(list_result.output.strip())
+
+    del_result = runner.invoke(app, ["delete", first["id"], "--db", str(populated_db)])
+    assert del_result.exit_code == 0
+    assert f"Deleted {first['id']}" in del_result.output
+
+    after = runner.invoke(app, ["list", "--db", str(populated_db)])
+    remaining = [json.loads(line) for line in after.output.splitlines() if line.strip()]
+    assert all(r["id"] != first["id"] for r in remaining)
+
+
+def test_delete_missing_id_fails(populated_db):
+    result = runner.invoke(
+        app, ["delete", "01HXXXXXXXXXXXXXXXXXXXXXXX", "--db", str(populated_db)]
+    )
+    assert result.exit_code == 1
+    assert "No entry" in result.output
+
+
+def test_list_filters_by_kind(populated_db):
+    pytest.importorskip("fastembed")
+
+    # Add a record of a different kind.
+    data = populated_db.parent / "second.jsonl"
+    data.write_text(json.dumps({"kind": "spell", "content": "lumos"}) + "\n")
+    runner.invoke(app, ["ingest", str(data), "--db", str(populated_db)])
+
+    result = runner.invoke(app, ["list", "--db", str(populated_db), "--kind", "spell"])
+    assert result.exit_code == 0
+    lines = [line for line in result.output.splitlines() if line.strip()]
+    assert len(lines) == 1
+    assert json.loads(lines[0])["kind"] == "spell"
+
+
+# ---------- info / add / search --dynamic-threshold ----------
+
+
+def test_info_reports_metadata_and_counts(populated_db):
+    result = runner.invoke(app, ["info", "--db", str(populated_db)])
+    assert result.exit_code == 0
+    parsed = json.loads(result.output.strip())
+    assert parsed["path"] == str(populated_db)
+    assert parsed["model"]
+    assert parsed["dimension"] > 0
+    assert parsed["schema_version"] == 1
+    assert parsed["entry_count"] == 2
+    assert parsed["kinds"] == {"note": 2}
+
+
+def test_info_rejects_non_grimoire_file(tmp_path):
+    import sqlite3
+
+    db = tmp_path / "stranger.db"
+    conn = sqlite3.connect(db)
+    conn.execute("CREATE TABLE other (x INTEGER)")
+    conn.commit()
+    conn.close()
+    result = runner.invoke(app, ["info", "--db", str(db)])
+    assert result.exit_code == 1
+    assert "No grimoire at" in result.output
+
+
+def test_info_reports_missing_path_with_friendly_error(tmp_path):
+    result = runner.invoke(app, ["info", "--db", str(tmp_path / "nope.db")])
+    assert result.exit_code == 1
+    assert "No grimoire at" in result.output
+
+
+def test_add_inserts_a_single_record(tmp_path):
+    pytest.importorskip("fastembed")
+
+    db = tmp_path / "store.db"
+    add_result = runner.invoke(
+        app, ["add", "the moon is full", "--kind", "note", "--db", str(db)]
+    )
+    assert add_result.exit_code == 0
+    parsed = json.loads(add_result.output.strip())
+    assert parsed["content"] == "the moon is full"
+    assert parsed["kind"] == "note"
+    assert "id" in parsed
+
+    list_result = runner.invoke(app, ["list", "--db", str(db)])
+    assert list_result.exit_code == 0
+    rows = [
+        json.loads(line) for line in list_result.output.splitlines() if line.strip()
+    ]
+    assert len(rows) == 1
+    assert rows[0]["id"] == parsed["id"]
+
+
+def test_add_rejects_non_object_payload(tmp_path):
+    pytest.importorskip("fastembed")
+
+    db = tmp_path / "store.db"
+    result = runner.invoke(
+        app, ["add", "hello", "--db", str(db), "--payload", '"just a string"']
+    )
+    assert result.exit_code == 1
+    assert "JSON object" in result.output
+
+
+def test_add_rejects_invalid_payload_json(tmp_path):
+    pytest.importorskip("fastembed")
+
+    db = tmp_path / "store.db"
+    result = runner.invoke(
+        app, ["add", "hello", "--db", str(db), "--payload", "{not json"]
+    )
+    assert result.exit_code == 1
+    assert "valid JSON" in result.output
+
+
+def test_search_dynamic_threshold_filters_results(tmp_path):
+    pytest.importorskip("fastembed")
+
+    db = tmp_path / "store.db"
+    # Two entries both gated on a very tight threshold (0.0); only an
+    # exact-match query should make it through.
+    data = tmp_path / "records.jsonl"
+    data.write_text(
+        json.dumps({"kind": "note", "content": "the moon is full", "threshold": 0.0})
+        + "\n"
+        + json.dumps(
+            {"kind": "note", "content": "dragons fly at midnight", "threshold": 0.0}
+        )
+        + "\n"
+    )
+    assert runner.invoke(app, ["ingest", str(data), "--db", str(db)]).exit_code == 0
+
+    ungated = runner.invoke(
+        app, ["search", "the moon is full", "--db", str(db), "--k", "5"]
+    )
+    assert ungated.exit_code == 0
+    assert len([line for line in ungated.output.splitlines() if line.strip()]) == 2
+
+    gated = runner.invoke(
+        app,
+        [
+            "search",
+            "the moon is full",
+            "--db",
+            str(db),
+            "--k",
+            "5",
+            "--dynamic-threshold",
+        ],
+    )
+    assert gated.exit_code == 0
+    gated_lines = [line for line in gated.output.splitlines() if line.strip()]
+    assert len(gated_lines) == 1
+    assert json.loads(gated_lines[0])["content"] == "the moon is full"