lorebase-cli 0.2.3__py3-none-any.whl → 0.3.1__py3-none-any.whl

lorebase_cli/__init__.py

@@ -1,3 +1,3 @@
 """lorebase CLI: command line client of a Lorebase Keeper."""
 
-__version__ = "0.2.3"
+__version__ = "0.3.1"

lorebase_cli/commands/agents.py

@@ -57,6 +57,20 @@ def context_command(
         list[str] | None,
         typer.Option("--relation", help="Follow only this Relation. Repeatable."),
     ] = None,
+    trait: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--trait",
+            help="Limit --search and --query seeds and neighbors to the Kinds implementing "
+            "this Trait. Repeatable.",
+        ),
+    ] = None,
+    lens: Annotated[
+        str | None,
+        typer.Option(
+            "--lens", help="Apply this lens: its Relations, depth, budget and Kinds are defaults."
+        ),
+    ] = None,
     domain: DomainOpt = None,
     branch: BranchOpt = None,
     at: AtOpt = None,
@@ -80,6 +94,8 @@ def context_command(
         budget_tokens=budget,
         depth=depth,
         relations=relation or None,
+        traits=trait or None,
+        lens=lens,
     )
     agents = app.client().agents
     name = app.domain(domain)

lorebase_cli/commands/data.py

@@ -1,9 +1,10 @@
-"""`import`, `record`, `query` and `search`: loading and reading Records and Links."""
+"""`import`, `record`, `query`, `search` and `resolve`: loading and reading Records and Links."""
 
 from __future__ import annotations
 
 import json
 import sys
+from collections.abc import Iterator
 from pathlib import Path
 from typing import Annotated, Any
 
@@ -638,15 +639,39 @@ def query_command(
         body["at"] = at
     client = app.client()
     domain_id = app.domain(domain)
+    first = client.records.query(domain_id, body)
     if body.get("aggregate"):
-        result = client.records.query(domain_id, body)
-        app.out.emit(result, lambda: _print_aggregate(app, result))
+        app.out.emit(first, lambda: _print_aggregate(app, first))
+        _print_coverage(app, first.coverage)
         return
-    items, more = app.take(client.records.iterate_query(domain_id, body), limit, everything)
+
+    def pages() -> Iterator[m.RecordItem]:
+        page = first
+        while True:
+            yield from page.items
+            if page.next_cursor is None:
+                return
+            # Only the request's own members: a Keeper older than the coverage block refuses
+            # unknown ones, so later pages repeat the first one's body with the cursor.
+            following = {**body, "cursor": page.next_cursor}
+            page = client.records.query(domain_id, following)
+
+    items, more = app.take(pages(), limit, everything)
     selected = [str(s) for s in body.get("select") or [] if s not in ("key", "title")]
     _print_records(app, items, selected)
     if more:
         app.note_truncated(len(items))
+    _print_coverage(app, first.coverage)
+
+
+def _print_coverage(app: AppContext, coverage: m.Coverage | None) -> None:
+    """The coverage notes (design 8.11), one line each, besides the results."""
+    if coverage is None:
+        return
+    for note in coverage.notes:
+        app.out.info(note)
+    if coverage.omitted:
+        app.out.info(f"coverage: {coverage.omitted}")
 
 
 def _query_body(text: str) -> dict[str, Any]:
@@ -691,6 +716,18 @@ def search_command(
     kind: Annotated[
         list[str] | None, typer.Option("--kind", help="Only this Kind. Repeatable.")
     ] = None,
+    trait: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--trait", help="Only the Kinds that implement this Trait. Repeatable; adds to --kind."
+        ),
+    ] = None,
+    lens: Annotated[
+        str | None,
+        typer.Option(
+            "--lens", help="Search the Kinds and Traits of this lens unless --kind or --trait."
+        ),
+    ] = None,
     mode: Annotated[
         str | None,
         typer.Option(
@@ -719,6 +756,8 @@ def search_command(
         {
             "q": text,
             "kinds": kind,
+            "traits": trait,
+            "lens": lens,
             "mode": mode,
             "query_vector": vector,
             "branch": app.branch(branch),
@@ -740,3 +779,78 @@ def search_command(
             ],
         ),
     )
+    if result.semantic_truncated:
+        app.out.info("the vector list is short: the index scan stopped at its bound; narrow --kind")
+
+
+def resolve_command(
+    ctx: typer.Context,
+    text: Annotated[str, typer.Argument(help="Words to ground, e.g. a question.", metavar="TEXT")],
+    kind: Annotated[
+        list[str] | None, typer.Option("--kind", help="Only look in this Kind. Repeatable.")
+    ] = None,
+    level: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--level",
+            help="exact, synonym, trigram or embedding (default: those the server enables). "
+            "Repeatable.",
+        ),
+    ] = None,
+    vector_file: Annotated[
+        str | None,
+        typer.Option(
+            "--vector-file",
+            help="Embedding of TEXT, enabling the embedding level when nothing else matched: a "
+            "JSON array, or the output of `lorebase-inference embed`; `-` reads standard input.",
+        ),
+    ] = None,
+    domain: DomainOpt = None,
+    branch: BranchOpt = None,
+    at: AtOpt = None,
+    limit: LimitOpt = None,
+    json_out: JsonOpt = False,
+) -> None:
+    """Ground the words of a text in Kinds, Attributes and stored values (with `where` fragments
+    in --json); it never runs a query."""
+    app = app_of(ctx, json_out)
+    vector = None if vector_file is None else query_vector(vector_file)
+    request = m.ResolveRequest.model_validate(
+        {
+            "text": text,
+            "kinds": kind,
+            "levels": level,
+            "query_vector": vector,
+            "branch": app.branch(branch),
+            "at": at,
+            "limit": limit or app.settings.list_limit,
+        }
+    )
+    result = app.client().records.resolve(app.domain(domain), request)
+
+    def rows() -> list[dict[str, Any]]:
+        return [
+            {**c.model_dump(), "ref": ".".join(filter(None, [c.kind, c.attribute]))}
+            for c in result.candidates
+        ]
+
+    app.out.emit(
+        result,
+        lambda: app.out.table(
+            rows(),
+            [
+                Column("target", "target"),
+                Column("kind.attribute", "ref"),
+                Column("values", "values"),
+                Column("level", "level"),
+                Column("score", "score", lambda v: f"{v:.3f}"),
+                Column("records", "records"),
+                Column("matched", "matched"),
+            ],
+        ),
+    )
+    for skipped in result.skipped:
+        app.out.info(f"{skipped.level} skipped: {skipped.reason}")
+    if result.unmatched:
+        app.out.info("unmatched: " + ", ".join(result.unmatched))
+    _print_coverage(app, result.coverage)

lorebase_cli/commands/documents.py

@@ -1,4 +1,6 @@
-"""`documents upload|list|get|text`: documents stored for extraction by Scribe."""
+"""`documents upload|list|versions|get|text|retire|purge`: documents stored for extraction by
+Scribe. Uploads with `--key` are versions of one source; retiring stops further extraction and
+purging irreversibly erases the content."""
 
 from __future__ import annotations
 
@@ -10,7 +12,7 @@ import typer
 from lorebase_cli.context import AppContext, app_of
 from lorebase_cli.failures import CliError
 from lorebase_cli.options import AllOpt, DomainOpt, JsonOpt, LimitOpt
-from lorebase_cli.output import Column, short_id
+from lorebase_cli.output import Column
 from lorebase_client import models as m
 
 documents_app = typer.Typer(
@@ -22,11 +24,20 @@ DOCUMENT_COLUMNS = [
     Column("filename", "filename"),
     Column("type", "media_type"),
     Column("size", "size"),
-    Column("sha256", "sha256", short_id),
+    Column("key", "source_key"),
+    Column("v", "version"),
+    Column("status", "status"),
     Column("created", "created_at"),
 ]
 
 
+KeyOpt = Annotated[
+    str | None,
+    typer.Option("--key", help="Source key (path, URL or external id): the document's identity."),
+]
+ReasonOpt = Annotated[str, typer.Option("--reason", help="Why, recorded in the audit.")]
+
+
 def _tiers(text: str | None) -> list[int] | None:
     """Extraction tiers from a comma separated list such as `0,1`."""
     if text is None:
@@ -44,9 +55,23 @@ def _document_pairs(found: m.Document) -> list[tuple[str, Any]]:
         ("media type", found.media_type),
         ("size", found.size),
         ("sha256", found.sha256),
+        ("source key", found.source_key),
+        ("version", found.version),
+        ("replaces", found.replaces),
+        ("status", found.status),
         ("text parsed", found.text_sha256 is not None),
         ("created", found.created_at),
         ("created by", found.created_by),
+        *(
+            [("retired", f"{found.retired_at} by {found.retired_by}")]
+            if found.retired_at is not None
+            else []
+        ),
+        *(
+            [("purged", f"{found.purged_at} by {found.purged_by}")]
+            if found.purged_at is not None
+            else []
+        ),
     ]
 
 
@@ -67,10 +92,14 @@ def documents_upload(
     tiers: Annotated[
         str | None, typer.Option("--tiers", help="Extraction tiers, comma separated (e.g. 0,1).")
     ] = None,
+    key: KeyOpt = None,
     domain: DomainOpt = None,
     json_out: JsonOpt = False,
 ) -> None:
-    """Upload a document (PATH, or --url) and queue its extraction."""
+    """Upload a document (PATH, or --url) and queue its extraction.
+
+    With --key, new bytes become a new version of the key's document.
+    """
     app = app_of(ctx, json_out)
     name = app.domain(domain)
     extract = False if no_extract else None
@@ -78,11 +107,11 @@ def documents_upload(
     documents = app.client().documents
     if path is not None and url is None:
         try:
-            uploaded = documents.upload(name, path, extract=extract, tiers=wanted)
+            uploaded = documents.upload(name, path, extract=extract, tiers=wanted, source_key=key)
         except OSError as error:
             raise CliError(f"cannot read {path}: {error.strerror or error}") from error
     elif url is not None and path is None:
-        uploaded = documents.upload_url(name, url, extract=extract, tiers=wanted)
+        uploaded = documents.upload_url(name, url, extract=extract, tiers=wanted, source_key=key)
     else:
         raise CliError("give PATH or --url")
     app.out.emit(
@@ -92,6 +121,7 @@ def documents_upload(
                 *_document_pairs(uploaded.document),
                 ("duplicate", uploaded.duplicate),
                 ("job", uploaded.job_id),
+                ("check job", uploaded.check_job_id),
             ]
         ),
     )
@@ -100,6 +130,9 @@ def documents_upload(
 @documents_app.command("list")
 def documents_list(
     ctx: typer.Context,
+    key: Annotated[
+        str | None, typer.Option("--key", help="Only the versions of this source key.")
+    ] = None,
     domain: DomainOpt = None,
     limit: LimitOpt = None,
     everything: AllOpt = False,
@@ -107,7 +140,26 @@ def documents_list(
 ) -> None:
     """List the documents of a Domain, newest first."""
     app = app_of(ctx, json_out)
-    items, more = app.take(app.client().documents.iterate(app.domain(domain)), limit, everything)
+    stream = app.client().documents.iterate(app.domain(domain), source_key=key)
+    items, more = app.take(stream, limit, everything)
+    app.out.emit(items, lambda: app.out.table([d.model_dump() for d in items], DOCUMENT_COLUMNS))
+    if more:
+        app.note_truncated(len(items))
+
+
+@documents_app.command("versions")
+def documents_versions(
+    ctx: typer.Context,
+    document_id: Annotated[str, typer.Argument(help="Document id.", metavar="ID")],
+    domain: DomainOpt = None,
+    limit: LimitOpt = None,
+    everything: AllOpt = False,
+    json_out: JsonOpt = False,
+) -> None:
+    """List the versions of a document's source key, newest first."""
+    app = app_of(ctx, json_out)
+    stream = app.client().documents.iterate_versions(app.domain(domain), document_id)
+    items, more = app.take(stream, limit, everything)
     app.out.emit(items, lambda: app.out.table([d.model_dump() for d in items], DOCUMENT_COLUMNS))
     if more:
         app.note_truncated(len(items))
@@ -159,3 +211,56 @@ def documents_text(
             app.out.info(f"text cut at {len(found.text)} of {found.length} characters")
 
     app.out.emit(found, human)
+
+
+@documents_app.command("retire")
+def documents_retire(
+    ctx: typer.Context,
+    document_id: Annotated[str, typer.Argument(help="Document id.", metavar="ID")],
+    reason: ReasonOpt,
+    domain: DomainOpt = None,
+    json_out: JsonOpt = False,
+) -> None:
+    """Retire a document: it is never extracted again and its evidence is re-checked."""
+    app = app_of(ctx, json_out)
+    done = app.client().documents.retire(app.domain(domain), document_id, reason=reason)
+    app.out.emit(
+        done,
+        lambda: app.out.pairs([*_document_pairs(done.document), ("check job", done.job_id)]),
+    )
+
+
+@documents_app.command("purge")
+def documents_purge(
+    ctx: typer.Context,
+    document_id: Annotated[str, typer.Argument(help="Document id.", metavar="ID")],
+    reason: ReasonOpt,
+    confirm: Annotated[
+        str, typer.Option("--confirm", help="The document id again: the purge is irreversible.")
+    ],
+    domain: DomainOpt = None,
+    json_out: JsonOpt = False,
+) -> None:
+    """Irreversibly erase a document's bytes, text, chunks and evidence quotes."""
+    if confirm != document_id:
+        raise CliError(f"--confirm must repeat the document id {document_id!r}")
+    app = app_of(ctx, json_out)
+    done = app.client().documents.purge(
+        app.domain(domain), document_id, reason=reason, confirm=confirm
+    )
+    app.out.emit(
+        done,
+        lambda: app.out.pairs(
+            [
+                *_document_pairs(done.document),
+                ("check job", done.job_id),
+                ("blob deleted", done.blob_deleted),
+                ("text deleted", done.text_deleted),
+                ("chunks", done.chunks),
+                ("cache entries", done.cache_entries),
+                ("items erased", done.items),
+                ("candidates erased", done.candidates),
+                ("suggestions erased", done.suggestions),
+            ]
+        ),
+    )

lorebase_cli/commands/proposals.py

@@ -9,7 +9,7 @@ import typer
 from lorebase_cli.commands.data import json_argument
 from lorebase_cli.context import AppContext, app_of
 from lorebase_cli.failures import CliError
-from lorebase_cli.options import AllOpt, DomainOpt, JsonOpt, LimitOpt
+from lorebase_cli.options import AllOpt, DomainOpt, JsonOpt, LimitOpt, MineOpt
 from lorebase_cli.output import Column, short_id
 from lorebase_client import models as m
 
@@ -26,6 +26,8 @@ PROPOSAL_COLUMNS = [
     Column("target", "target_ref"),
     Column("status", "status"),
     Column("author", "author"),
+    Column("stewards", "steward_roles"),
+    Column("assignees", "assignees"),
     Column("created", "created_at"),
 ]
 CONFLICT_COLUMNS = [
@@ -111,6 +113,7 @@ def proposal_list(
     author: Annotated[
         str | None, typer.Option("--author", help="Only Proposals by this principal.")
     ] = None,
+    mine: MineOpt = False,
     domain: DomainOpt = None,
     limit: LimitOpt = None,
     everything: AllOpt = False,
@@ -125,6 +128,7 @@ def proposal_list(
             source=source,
             target=target,
             author=author,
+            assigned="me" if mine else None,
         ),
         limit,
         everything,

lorebase_cli/commands/reconcile.py

@@ -0,0 +1,233 @@
+"""`reconcile list|show|resolve|dismiss|reopen`: the reconciliation queue."""
+
+from __future__ import annotations
+
+from typing import Annotated, Any, cast, get_args
+
+import typer
+
+from lorebase_cli.commands.data import json_argument
+from lorebase_cli.context import AppContext, app_of
+from lorebase_cli.failures import CliError
+from lorebase_cli.options import AllOpt, BranchOpt, DomainOpt, JsonOpt, LimitOpt, MineOpt
+from lorebase_cli.output import Column
+from lorebase_client import models as m
+
+reconcile_app = typer.Typer(
+    help="Review contradictions and duplicates between Sources.", no_args_is_help=True
+)
+
+CandidateArg = Annotated[str, typer.Argument(help="Candidate id.", metavar="ID")]
+ReasonOpt = Annotated[str, typer.Option("--reason", "-r", help="Why; kept in the audit log.")]
+
+CANDIDATE_COLUMNS = [
+    Column("id", "id"),
+    Column("type", "type"),
+    Column("status", "status"),
+    Column("kind", "kind"),
+    Column("keys", "keys", lambda keys: ", ".join(keys)),
+    Column("attribute", "attribute"),
+    Column("claims", "claim_count"),
+    Column("stewards", "steward_roles"),
+    Column("assignees", "assignees"),
+    Column("created", "created_at"),
+]
+
+
+def _show_candidate(app: AppContext, found: m.ReconciliationCandidate) -> None:
+    pairs: list[tuple[str, Any]] = [
+        ("candidate", found.id),
+        ("branch", found.branch),
+        ("type", found.type),
+        ("status", found.status),
+        ("kind", found.kind),
+        ("keys", found.keys),
+        ("attribute", found.attribute),
+        (
+            "claims",
+            [
+                f"{c.claim_id}: {c.value!r}" + (f" ({c.source})" if c.source else "")
+                for c in found.claims
+            ],
+        ),
+        ("claim count", found.claim_count),
+        ("proposal", found.proposal_id),
+        ("decided by", found.decided_by),
+        ("decided at", found.decided_at),
+        ("created", found.created_at),
+        ("updated", found.updated_at),
+    ]
+    app.out.pairs(pairs)
+
+
+def _show_decision(app: AppContext, decided: m.ReconciliationDecision) -> None:
+    app.out.pairs(
+        [
+            ("candidate", decided.candidate.id),
+            ("status", decided.status),
+            ("claim", decided.claim_id),
+            ("branch", decided.branch),
+            ("revision", decided.revision),
+            ("proposal", decided.proposal),
+            ("detail", decided.detail),
+        ]
+    )
+
+
+def _checked(value: str | None, allowed: Any, option: str) -> str | None:
+    """`value` checked against the members of a Literal type."""
+    if value is not None and value not in get_args(allowed):
+        raise CliError(f"{option}: unknown {value!r}, use {', '.join(get_args(allowed))}")
+    return value
+
+
+@reconcile_app.command("list")
+def reconcile_list(
+    ctx: typer.Context,
+    candidate_type: Annotated[
+        str | None,
+        typer.Option("--type", help="duplicate, contradiction, superseded or stale."),
+    ] = None,
+    status: Annotated[
+        str | None,
+        typer.Option("--status", help="open, resolved, dismissed or obsolete (default: all)."),
+    ] = None,
+    kind: Annotated[str | None, typer.Option("--kind", help="Only this Kind (api name).")] = None,
+    attribute: Annotated[
+        str | None,
+        typer.Option("--attribute", help="Only this Attribute (api name; needs --kind)."),
+    ] = None,
+    source: Annotated[
+        str | None,
+        typer.Option("--source", help="Only candidates with a claim of this Source identity."),
+    ] = None,
+    mine: MineOpt = False,
+    domain: DomainOpt = None,
+    branch: BranchOpt = None,
+    limit: LimitOpt = None,
+    everything: AllOpt = False,
+    json_out: JsonOpt = False,
+) -> None:
+    """List the candidates of a branch, newest first."""
+    chosen_type = _checked(candidate_type, m.CandidateType, "--type")
+    chosen_status = _checked(status, m.CandidateStatus, "--status")
+    app = app_of(ctx, json_out)
+    items, more = app.take(
+        app.client().reconciliation.iterate(
+            app.domain(domain),
+            branch=app.branch(branch),
+            type=cast("m.CandidateType | None", chosen_type),
+            status=cast("m.CandidateStatus | None", chosen_status),
+            kind=kind,
+            attribute=attribute,
+            source=source,
+            assigned="me" if mine else None,
+        ),
+        limit,
+        everything,
+    )
+    app.out.emit(items, lambda: app.out.table([c.model_dump() for c in items], CANDIDATE_COLUMNS))
+    if more:
+        app.note_truncated(len(items))
+
+
+@reconcile_app.command("show")
+def reconcile_show(
+    ctx: typer.Context,
+    candidate_id: CandidateArg,
+    domain: DomainOpt = None,
+    json_out: JsonOpt = False,
+) -> None:
+    """Show a candidate with its claims and last decision."""
+    app = app_of(ctx, json_out)
+    found = app.client().reconciliation.get(app.domain(domain), candidate_id)
+    app.out.emit(found, lambda: _show_candidate(app, found))
+
+
+@reconcile_app.command("resolve")
+def reconcile_resolve(
+    ctx: typer.Context,
+    candidate_id: CandidateArg,
+    choice: Annotated[
+        str, typer.Option("--choice", help="claim, keep_current, custom, policy or merge.")
+    ],
+    reason: ReasonOpt,
+    claim: Annotated[
+        str | None, typer.Option("--claim", help="Claim id to take (choice `claim`).")
+    ] = None,
+    value: Annotated[
+        str | None,
+        typer.Option("--value", help="Value of a `custom` choice: inline JSON, @file or -."),
+    ] = None,
+    policy: Annotated[
+        str | None,
+        typer.Option(
+            "--policy",
+            help="authority, newest_wins, prefer_current or prefer_incoming (choice `policy`).",
+        ),
+    ] = None,
+    survivor: Annotated[
+        str | None, typer.Option("--survivor", help="Key of the Record that stays (`merge`).")
+    ] = None,
+    values: Annotated[
+        str | None,
+        typer.Option(
+            "--values",
+            help="Values to set on the survivor, by Attribute api name (`merge`): "
+            "a JSON object, inline, @file or -.",
+        ),
+    ] = None,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Report the outcome without writing.")
+    ] = False,
+    domain: DomainOpt = None,
+    json_out: JsonOpt = False,
+) -> None:
+    """Decide a candidate; a write that needs review opens a Proposal."""
+    chosen = _checked(choice, m.ReconcileChoice, "--choice")
+    chosen_policy = _checked(policy, m.ReconcilePolicy, "--policy")
+    parsed = None if values is None else json_argument(values)
+    if parsed is not None and not isinstance(parsed, dict):
+        raise CliError("--values is a JSON object")
+    app = app_of(ctx, json_out)
+    decided = app.client().reconciliation.resolve(
+        app.domain(domain),
+        candidate_id,
+        cast("m.ReconcileChoice", chosen),
+        reason=reason,
+        claim_id=claim,
+        value=None if value is None else json_argument(value),
+        policy=cast("m.ReconcilePolicy | None", chosen_policy),
+        survivor=survivor,
+        values=parsed,
+        dry_run=dry_run,
+    )
+    app.out.emit(decided, lambda: _show_decision(app, decided))
+
+
+@reconcile_app.command("dismiss")
+def reconcile_dismiss(
+    ctx: typer.Context,
+    candidate_id: CandidateArg,
+    reason: ReasonOpt,
+    domain: DomainOpt = None,
+    json_out: JsonOpt = False,
+) -> None:
+    """Dismiss a candidate: the difference is accepted as it is."""
+    app = app_of(ctx, json_out)
+    decided = app.client().reconciliation.dismiss(app.domain(domain), candidate_id, reason=reason)
+    app.out.emit(decided, lambda: _show_decision(app, decided))
+
+
+@reconcile_app.command("reopen")
+def reconcile_reopen(
+    ctx: typer.Context,
+    candidate_id: CandidateArg,
+    reason: ReasonOpt,
+    domain: DomainOpt = None,
+    json_out: JsonOpt = False,
+) -> None:
+    """Reopen a dismissed candidate."""
+    app = app_of(ctx, json_out)
+    decided = app.client().reconciliation.reopen(app.domain(domain), candidate_id, reason=reason)
+    app.out.emit(decided, lambda: _show_decision(app, decided))

lorebase_cli/context.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import itertools
+import os
 from collections.abc import Callable, Iterable
 from dataclasses import dataclass, field
 
@@ -10,7 +11,7 @@ import typer
 
 from lorebase_cli.failures import CliError
 from lorebase_cli.output import Output
-from lorebase_cli.settings import ENV_DOMAIN, CliSettings
+from lorebase_cli.settings import ENV_DOMAIN, CliSettings, default_config_path
 from lorebase_client import LorebaseClient
 
 ClientFactory = Callable[[CliSettings], LorebaseClient]
@@ -19,6 +20,12 @@ ClientFactory = Callable[[CliSettings], LorebaseClient]
 def default_client(settings: CliSettings) -> LorebaseClient:
     """A client for the configured server. (Imports send idempotency keys themselves; creating
     things does not, so that creating what exists is reported as a conflict.)"""
+    if not settings.url:
+        path = settings.config_path or default_config_path(os.environ)
+        raise CliError(
+            f"no server URL: pass --url, set LOREBASE_URL or `url` in a profile of the config "
+            f"file ({path})"
+        )
     return LorebaseClient(
         settings.url,
         api_prefix=settings.api_prefix,

lorebase_cli/main.py

@@ -20,6 +20,7 @@ from lorebase_cli.commands import (
     domains,
     history,
     proposals,
+    reconcile,
     schema,
     sources,
     trace,
@@ -139,11 +140,13 @@ app.add_typer(admin.admin_app, name="admin")
 app.add_typer(audit.audit_app, name="audit")
 app.add_typer(trace.trace_app, name="trace")
 app.add_typer(proposals.proposal_app, name="proposal")
+app.add_typer(reconcile.reconcile_app, name="reconcile")
 app.add_typer(sources.sources_app, name="sources")
 app.add_typer(documents.documents_app, name="documents")
 app.command("whoami")(domains.whoami)
 app.command("query")(data.query_command)
 app.command("search")(data.search_command)
+app.command("resolve")(data.resolve_command)
 app.command("log")(history.log_command)
 app.command("diff")(history.diff_command)
 app.command("context")(agents.context_command)

lorebase_cli/options.py

@@ -54,3 +54,6 @@ LimitOpt = Annotated[
     typer.Option("--limit", "-n", min=1, help="Most items to print (default: list_limit setting)."),
 ]
 AllOpt = Annotated[bool, typer.Option("--all", help="Print every item, however many.")]
+MineOpt = Annotated[
+    bool, typer.Option("--mine", help="Only items assigned to you through a steward role.")
+]

lorebase_cli-0.3.1.dist-info/METADATA

@@ -0,0 +1,41 @@
+Metadata-Version: 2.5
+Name: lorebase-cli
+Version: 0.3.1
+Summary: Lorebase CLI
+Project-URL: Homepage, https://github.com/aantenore/lorebase
+Project-URL: Documentation, https://aantenore.github.io/lorebase/
+Project-URL: Repository, https://github.com/aantenore/lorebase
+Project-URL: Changelog, https://github.com/aantenore/lorebase/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/aantenore/lorebase/issues
+Author: Antonio Antenore
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: knowledge-graph,mcp,ontology,postgres,versioning
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Requires-Python: >=3.12
+Requires-Dist: lorebase-client<0.4,>=0.3
+Requires-Dist: typer>=0.27
+Provides-Extra: linkml
+Requires-Dist: pyyaml>=6.0; extra == 'linkml'
+Provides-Extra: parquet
+Requires-Dist: pyarrow>=15; extra == 'parquet'
+Description-Content-Type: text/markdown
+
+# lorebase-cli
+
+Part of [Lorebase](https://github.com/aantenore/lorebase), an open-source ontology platform: a versioned, governed knowledge graph on Postgres with git-like branching and three-way merge.
+
+The `lorebase` command line for a Keeper: schema, records, imports, branches, merges, search and queries.
+
+```sh
+uv tool install lorebase-cli    # or: pip install lorebase-cli
+lorebase --help
+```
+
+Documentation: [Manual setup](https://aantenore.github.io/lorebase/manual-setup/) and the [documentation site](https://aantenore.github.io/lorebase/). License: Apache-2.0.

{lorebase_cli-0.2.3.dist-info → lorebase_cli-0.3.1.dist-info}/RECORD

@@ -1,30 +1,32 @@
-lorebase_cli/__init__.py,sha256=WaRCGYJ-OeKg1iQYpvl-vnJ48G7NPGnsdDwWeaBfl6o,85
+lorebase_cli/__init__.py,sha256=SbmcWvTjAQ_35AWYdG656PU6EPgeuP2GmifQ23hDhoo,85
 lorebase_cli/__main__.py,sha256=mrbDZBnLym1bpDIpgTL1L1_iytsbMRrnBrIJZsRuoTc,76
 lorebase_cli/batch_import.py,sha256=HOaK0IBF5gKKnnurc34BcBh2kb4eHr3LBzgl1ZiB2wY,12650
 lorebase_cli/coercion.py,sha256=m4zHFHvGpUehbGaLksBau5gnc7DiQ9Dj7UaPGH2ugTw,6413
-lorebase_cli/context.py,sha256=Aqu3eL9Nvq77Hau9O8EHsjAXJ3yY4NIesC78POLct4M,3381
+lorebase_cli/context.py,sha256=w8zcSEP4_PPO_E9nNjtYVKtTxyjd4hKQRCHBTyB9jF4,3667
 lorebase_cli/failures.py,sha256=UShNuEh6aQZ6IyMQmq12zDkx6OZcpg1WtRS69iPCtPU,6791
 lorebase_cli/importing.py,sha256=ScU7RreZ_awd8o5foPGQr1270mSu8r1JIJyEk6n72Hw,9261
 lorebase_cli/linkml.py,sha256=jhbRvDg7rGMCtlld76L-gl-DqF5FY0w2pmubz2IvzgI,69622
-lorebase_cli/main.py,sha256=2Voa3pNGpXVPE3J2VZ0BidqJhvW7GaQwTfP0Ld8Yn5s,5533
-lorebase_cli/options.py,sha256=Z5GCA7lOFIgmM8RDsTqso1U6h136Heu5zQCmPHo3ffc,1698
+lorebase_cli/main.py,sha256=Zi2dcWh6GrJEGeLqii-fnLAkZAKxcKKEbuII707CRqg,5650
+lorebase_cli/options.py,sha256=bcDV3CYPbJPS_RgaiX6RnSgulkMaGIGMYn1ea_k_Wh4,1813
 lorebase_cli/output.py,sha256=Lr0n03SKomt3kOTu8-NLgsewvHBp-2UDJZ2_8zDv2p4,5610
 lorebase_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lorebase_cli/settings.py,sha256=wcD1WHMy2pVqDXKJduux_i2RtwW9rZYMJyE9MAC9Fq8,6159
 lorebase_cli/sources.py,sha256=Am6alJN_SL6j06PeCKp6IYfboRIFyieA6cXhWPBWD8A,4024
 lorebase_cli/commands/__init__.py,sha256=h3N31KSCa8vuU6OoxKib8pHICh1xk7OAqmkxN1k-fb4,42
 lorebase_cli/commands/admin.py,sha256=Dv4W-d0SBzEfCkYB0VMk257RHP2h3HZJYIWaOc3UYLU,9300
-lorebase_cli/commands/agents.py,sha256=8Himq5Rf72X_aIpcjY1oib9mT-5ljfMB6jRBWIk25Vk,8146
+lorebase_cli/commands/agents.py,sha256=DiJk3d8vI3hFghH-6jHfhesNtMZNqqU4l7lJWRpW-4c,8632
 lorebase_cli/commands/audit.py,sha256=Su7jPzqSzQbKd7YkRSISHQVLupPD1ZRR1fLCq_cc8dA,1601
-lorebase_cli/commands/data.py,sha256=zVgmKgY2b-6ZLee4IVLZLwnvuy-BJgiOdFK1_xT3fQo,25010
-lorebase_cli/commands/documents.py,sha256=krcGi-UdWeMh4HIrLeoItYXybJgQVTyDGtuK_DpOdeY,5288
+lorebase_cli/commands/data.py,sha256=N7uvbbw5vEtnY4ZGl6eEekzKE49hDc6bKEejUn6hluM,28994
+lorebase_cli/commands/documents.py,sha256=Lfd4SfKyIvp76EJLFUobpylQfoAT-gw9sJl0XZUSfb4,9101
 lorebase_cli/commands/domains.py,sha256=vX73JcSz-th-bjGsZo-P17yoB79bwPdkOO3zNq8k020,14601
 lorebase_cli/commands/history.py,sha256=wkU02Rb30WQczYWr1rQU1VAdse6M1iQwAMd298cQ6Ss,7079
-lorebase_cli/commands/proposals.py,sha256=1pFVDvn4OTBRT5RHXr0B6VPKC-c6I7ivJSrsy0wDAZo,16474
+lorebase_cli/commands/proposals.py,sha256=Y-cKsklox55fdKeZ4EpWZ1SNst7xVbfVNVJxqZfgmW4,16634
+lorebase_cli/commands/reconcile.py,sha256=lf308KVp3zJCCuZOANwyPPtXvNB2N1AJFZmQSiz_OuE,8068
 lorebase_cli/commands/schema.py,sha256=ymkUGMfE3LfFVXFyN5L_cJIlm3kEL3D5Zj1Lp-3ohSE,17364
 lorebase_cli/commands/sources.py,sha256=YZNT20M28_xdWBQQ_TKmMScZkb0A-BaXJr4Dv4dXwoo,2079
 lorebase_cli/commands/trace.py,sha256=0aaYL3f3K29NmRcSzaV2LlugmoM7yMhE87AoMRb_YfA,4597
-lorebase_cli-0.2.3.dist-info/METADATA,sha256=Sp1HeHdQZm96qSJWmdlfUFnGWlneD6A9qeiqlYMnA2o,310
-lorebase_cli-0.2.3.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lorebase_cli-0.2.3.dist-info/entry_points.txt,sha256=RZqd8q81-mrfZq6cDj3CitYvTmLhADDCTkw9rvSMJ30,52
-lorebase_cli-0.2.3.dist-info/RECORD,,
+lorebase_cli-0.3.1.dist-info/METADATA,sha256=jrp3v0MwQN-FNr6int4_6Z6RaLRiGWotDR7m3nLnr8U,1727
+lorebase_cli-0.3.1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+lorebase_cli-0.3.1.dist-info/entry_points.txt,sha256=RZqd8q81-mrfZq6cDj3CitYvTmLhADDCTkw9rvSMJ30,52
+lorebase_cli-0.3.1.dist-info/licenses/LICENSE,sha256=15eYfzonmV-6lWJQEwBVClbvLGXtLQcIaIS7XVAtBv0,11346
+lorebase_cli-0.3.1.dist-info/RECORD,,

{lorebase_cli-0.2.3.dist-info → lorebase_cli-0.3.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.32.4
+Generator: hatchling 1.33.0
 Root-Is-Purelib: true
 Tag: py3-none-any

lorebase_cli-0.3.1.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Antonio Antenore
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

lorebase_cli-0.2.3.dist-info/METADATA

@@ -1,11 +0,0 @@
-Metadata-Version: 2.5
-Name: lorebase-cli
-Version: 0.2.3
-Summary: Lorebase CLI
-Requires-Python: >=3.12
-Requires-Dist: lorebase-client<0.3,>=0.2
-Requires-Dist: typer>=0.27
-Provides-Extra: linkml
-Requires-Dist: pyyaml>=6.0; extra == 'linkml'
-Provides-Extra: parquet
-Requires-Dist: pyarrow>=15; extra == 'parquet'