uro-cli 0.6.0__tar.gz → 0.7.0__tar.gz

{uro_cli-0.6.0 → uro_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: uro-cli
-Version: 0.6.0
+Version: 0.7.0
 Summary: Uro Engine reference client — play, dry-run, and dev tools against the engine
 Project-URL: Homepage, https://github.com/cupskeee/uro
 Project-URL: Repository, https://github.com/cupskeee/uro
@@ -12,8 +12,8 @@ Requires-Python: >=3.12
 Requires-Dist: python-dotenv>=1.0
 Requires-Dist: rich>=13.9
 Requires-Dist: typer>=0.27.2
-Requires-Dist: uro-core[llm,postgres]==0.6.0
-Requires-Dist: uro-server==0.6.0
+Requires-Dist: uro-core[llm,postgres]==0.7.0
+Requires-Dist: uro-server==0.7.0
 Requires-Dist: websockets>=16.1
 Description-Content-Type: text/markdown
 

{uro_cli-0.6.0 → uro_cli-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uro-cli"
-version = "0.6.0"
+version = "0.7.0"
 description = "Uro Engine reference client — play, dry-run, and dev tools against the engine"
 license = "MIT"
 license-files = ["LICENSE"]
@@ -13,8 +13,8 @@ requires-python = ">=3.12"
 # pair a new uro-cli with an old uro-core; `just release` bumps all three together, and the
 # `{workspace = true}` sources make a drifted pin fail `uv sync` locally.
 dependencies = [
-    "uro-core[postgres,llm]==0.6.0",
-    "uro-server==0.6.0",
+    "uro-core[postgres,llm]==0.7.0",
+    "uro-server==0.7.0",
     "typer>=0.27.2",
     "rich>=13.9",
     "websockets>=16.1",

{uro_cli-0.6.0 → uro_cli-0.7.0}/uro_cli/main.py

@@ -11,7 +11,7 @@ import json
 import sys
 import time
 import webbrowser
-from collections.abc import Awaitable
+from collections.abc import AsyncIterator, Awaitable
 from pathlib import Path
 from typing import Any
 
@@ -88,6 +88,27 @@ _ROLES = tuple(sorted(ROLES))
 PARTICIPANT = "player-1"  # Phase 0 is single-player; participants arrive in Phase 5.
 
 
+@contextlib.asynccontextmanager
+async def _metered(router: ProviderRouter) -> AsyncIterator[ProviderRouter]:
+    """Meter a command's model calls when the database is reachable (D-66). Best effort: `world
+    backfill` and `world probe` work on a pack file alone, so a down database never stops them —
+    their calls just go unrecorded."""
+    store: PostgresEventStore | None = None
+    try:
+        connecting = build_store()
+        await asyncio.wait_for(connect_store(connecting), timeout=5)
+        store = connecting
+    except Exception:
+        pass  # no database: run unmetered
+    if store is not None:
+        router.recorder = store.record_llm_call
+    try:
+        yield router
+    finally:
+        if store is not None:
+            await store.close()
+
+
 def _run_async(coro_factory) -> None:  # type: ignore[no-untyped-def]
     """Run an async command, turning config/credential/lookup errors into a clean message."""
     try:
@@ -278,6 +299,8 @@ def world_create(
             needs_fill = backfill and check_sufficiency(pack).grade != "runnable"
             router = build_router(provider, model) if needs_fill else None
             await connect_store(store)
+            if router is not None:  # the backfill's calls are metered like any other (D-66)
+                router.recorder = store.record_llm_call
             result = await import_pack(store, pack, backfill_router=router)
         except PackError as exc:
             typer.echo(f"error: {exc}", err=True)
@@ -353,7 +376,8 @@ def world_backfill(
         if before.grade == "runnable":
             typer.echo("pack is already runnable — nothing to backfill")
             return
-        augmented, added = await backfill_gaps(pack, build_router(provider, model), report=before)
+        async with _metered(build_router(provider, model)) as router:
+            augmented, added = await backfill_gaps(pack, router, report=before)
         after = check_sufficiency(augmented)
         typer.echo(f"backfill: {before.grade} → {after.grade}")
         for a in added:
@@ -384,7 +408,8 @@ def world_probe(
         except PackError as exc:
             typer.echo(f"error: {exc}", err=True)
             raise typer.Exit(1) from exc
-        report = await run_probes(pack.manifest, build_router(provider, model), tries=tries)
+        async with _metered(build_router(provider, model)) as router:
+            report = await run_probes(pack.manifest, router, tries=tries)
         typer.echo(f"probe report for {report.world}: {'OK' if report.ok else 'ISSUES'}")
         for r in report.results:
             gate = f"  (gates {r.gate_for})" if r.gate_for else ""
@@ -552,6 +577,13 @@ def serve(
         "(consensus). UNSET = auto (solo for 1 token, party for >1). Setting it EXPLICITLY binds "
         "that shape even for a 1-token launch, so a runtime-added player still gets turns (D-39).",
     ),
+    nats_url: str = typer.Option(
+        None,
+        "--nats",
+        help="push every commit — from any process — to WebSocket clients live, via the NATS "
+        "subjects `uro outbox relay` publishes to (D-67)",
+    ),
+    subject_prefix: str = typer.Option("uro", "--subject-prefix", help="the relay's prefix"),
     cors_origin: list[str] = typer.Option(  # noqa: B008
         None,
         "--cors-origin",
@@ -616,7 +648,14 @@ def serve(
     else:
         arbiter = shapes[arbiter_kind]()
     deps = engine_deps(store, engine, tokens, admin_tokens, router=router)
-    fastapi_app = create_app(deps, arbiter=arbiter, cors_origins=cors_origin or None)
+    commit_feed = None
+    if nats_url:
+        from uro_core.adapters.nats import NatsCommitFeed
+
+        commit_feed = NatsCommitFeed(nats_url, subject_prefix=subject_prefix)
+    fastapi_app = create_app(
+        deps, arbiter=arbiter, cors_origins=cors_origin or None, commit_feed=commit_feed
+    )
 
     @fastapi_app.on_event("startup")
     async def _startup() -> None:
@@ -641,6 +680,8 @@ def serve(
         typer.echo(f"  token {t!r} → {p}")
     if cors_origin:
         typer.echo(f"  CORS: allowing {', '.join(cors_origin)}")
+    if nats_url:
+        typer.echo(f"  live commits: {nats_url} ({subject_prefix}.>) — run `uro outbox relay` too")
     uvicorn.run(fastapi_app, host=host, port=port, log_level="warning")
 
 
@@ -699,6 +740,11 @@ def connect(
                             )
                         elif kind == "beat_failed":
                             typer.echo(f"\n  ✗ beat failed: {msg['error']}")
+                        elif kind == "commit":  # made elsewhere: another server, the CLI (D-67)
+                            for beat in msg.get("beats") or []:
+                                typer.echo(f"\n[{beat['participant_id']}] {beat['narration']}")
+                            if not msg.get("beats"):
+                                typer.echo("\n  · the world changed (no new narration)")
                         elif kind in ("participant_joined", "participant_left"):
                             typer.echo(f"  · {msg['participant_id']} {kind.split('_')[1]}")
 
@@ -1174,15 +1220,29 @@ def chronicle(
     _run_async(_run)
 
 
+async def _call_scope(
+    store: PostgresEventStore, world: str | None, campaign: str | None
+) -> tuple[str | None, list[str] | None]:
+    """--world / --campaign → (world_id, branch_ids); a campaign's calls are its branch's (D-66)."""
+    world_id = (await _world_or_exit(store, world)).world_id if world else None
+    branch_ids = [(await _campaign_or_exit(store, campaign)).branch_id] if campaign else None
+    return world_id, branch_ids
+
+
 @app.command()
-def usage(stage: str = typer.Option(None, "--stage", help="only this pipeline stage")) -> None:
-    """LLM-call telemetry by stage: calls, models, tokens (0 until metered), average latency."""
+def usage(
+    stage: str = typer.Option(None, "--stage", help="only this pipeline stage"),
+    world: str = typer.Option(None, "--world", help="only calls that served this world"),
+    campaign: str = typer.Option(None, "--campaign", help="only calls on this campaign's branch"),
+) -> None:
+    """LLM-call telemetry by stage: calls, models, token counts, average latency (D-66)."""
 
     async def _run() -> None:
         store = build_store()
         await connect_store(store)
         try:
-            rows = await store.usage_by_stage(stage)
+            world_id, branch_ids = await _call_scope(store, world, campaign)
+            rows = await store.usage_by_stage(stage, world_id=world_id, branch_ids=branch_ids)
         finally:
             await store.close()
         typer.echo(f"total calls: {sum(int(r['calls']) for r in rows)}")
@@ -1192,6 +1252,40 @@ def usage(stage: str = typer.Option(None, "--stage", help="only this pipeline st
     _run_async(_run)
 
 
+@app.command()
+def calls(
+    stage: str = typer.Option(None, "--stage", help="e.g. extractor, planner"),
+    world: str = typer.Option(None, "--world", help="only calls that served this world"),
+    campaign: str = typer.Option(None, "--campaign", help="only calls on this campaign's branch"),
+    limit: int = typer.Option(5, "--limit", min=1, max=200, help="how many, newest first"),
+) -> None:
+    """Recent LLM calls with what each structured one returned (D-66) — e.g. the extractor's raw
+    JSON for a beat that committed less than its narration said."""
+
+    async def _run() -> None:
+        store = build_store()
+        await connect_store(store)
+        try:
+            world_id, branch_ids = await _call_scope(store, world, campaign)
+            rows = await store.recent_llm_calls(
+                stage=stage, world_id=world_id, branch_ids=branch_ids, limit=limit
+            )
+        finally:
+            await store.close()
+        if not rows:
+            typer.echo("(no metered calls)")
+        for r in rows:
+            tokens = f"{r['tokens_in'] or '?'}→{r['tokens_out'] or '?'} tokens"
+            typer.echo(
+                f"{r['created_at']:%Y-%m-%d %H:%M:%S}  {r['stage_tag']:<10} {r['model'] or '-'}  "
+                f"{tokens}  {r['latency_ms']}ms"
+            )
+            if r["response"] is not None:
+                typer.echo(f"  {r['response']}")
+
+    _run_async(_run)
+
+
 @ruleset_app.command("list")
 def ruleset_list() -> None:
     """The rulesets a world can declare (`[ruleset] id` in world.toml): the built-ins and installed