rubricloop 0.1.2__tar.gz → 0.1.4__tar.gz

{rubricloop-0.1.2 → rubricloop-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: rubricloop
-Version: 0.1.2
+Version: 0.1.4
 Summary: Bounded, auditable verification loops for AI agent output.
 Project-URL: Homepage, https://rubricloop.com
 Project-URL: Documentation, https://rubricloop.com/docs
@@ -179,10 +179,11 @@ When the package is ready to share, create an API key in the
 hosted registry:
 
 ```bash
-rubricloop --server https://api.rubricloop.dev login --api-key "$RUBRICLOOP_API_KEY"
-rubricloop --server https://api.rubricloop.dev push dist/acme-check.rlpack --tag latest
-rubricloop --server https://api.rubricloop.dev vet acme/check@latest
-rubricloop --server https://api.rubricloop.dev pull acme/check@latest
+rubricloop login --api-key "$RUBRICLOOP_API_KEY"
+rubricloop create acme/check --visibility private
+rubricloop push dist/acme-check.rlpack --tag latest
+rubricloop vet acme/check@latest
+rubricloop pull acme/check@latest
 ```
 
 Public community packages are free. Private repositories are available only to

{rubricloop-0.1.2 → rubricloop-0.1.4}/README.md

@@ -150,10 +150,11 @@ When the package is ready to share, create an API key in the
 hosted registry:
 
 ```bash
-rubricloop --server https://api.rubricloop.dev login --api-key "$RUBRICLOOP_API_KEY"
-rubricloop --server https://api.rubricloop.dev push dist/acme-check.rlpack --tag latest
-rubricloop --server https://api.rubricloop.dev vet acme/check@latest
-rubricloop --server https://api.rubricloop.dev pull acme/check@latest
+rubricloop login --api-key "$RUBRICLOOP_API_KEY"
+rubricloop create acme/check --visibility private
+rubricloop push dist/acme-check.rlpack --tag latest
+rubricloop vet acme/check@latest
+rubricloop pull acme/check@latest
 ```
 
 Public community packages are free. Private repositories are available only to

rubricloop-0.1.4/examples/verify_reply_registry/README.md

@@ -0,0 +1,65 @@
+# Reply Quick Start registry lifecycle
+
+This package uses the same three deterministic rules as
+`sdk/examples/verify_reply.py`: 40 to 70 words, the word `timeline`, and no
+`guaranteed refund` promise.
+
+You can run the same checks through Hosted Verification before publishing and
+vetting your own package:
+
+```bash
+curl https://api.rubricloop.dev/v1/verify \
+  -H "Content-Type: application/json" \
+  -H "X-API-Key: $RUBRICLOOP_API_KEY" \
+  -d '{
+    "pack_id": "support/reply-v1",
+    "output": {
+      "reply": "We apologize for the delay with your order. Our team is currently investigating the issue and working to resolve it as quickly as possible. You can expect an update on the timeline for your order shortly. Thank you for your patience."
+    },
+    "context": {}
+  }'
+```
+
+To publish the package itself:
+
+```bash
+pip install rubricloop openai
+export OPENAI_API_KEY="sk-..."
+python sdk/examples/verify_reply.py
+
+python sdk/examples/verify_reply_registry/build_package.py \
+  --namespace YOUR_NAMESPACE
+
+rubricloop login
+rubricloop create \
+  YOUR_NAMESPACE/support-reply \
+  --visibility private \
+  --description "Checks support replies before they are sent."
+rubricloop validate dist/support-reply.rlpack
+rubricloop test dist/support-reply.rlpack
+rubricloop push \
+  dist/support-reply.rlpack \
+  --tag latest
+rubricloop vet \
+  YOUR_NAMESPACE/support-reply@latest
+```
+
+Pull the immutable bundle digest returned by `push`, not the mutable tag:
+
+```bash
+rubricloop pull \
+  YOUR_NAMESPACE/support-reply@sha256:BUNDLE_DIGEST \
+  --output dist/pulled-support-reply.rlpack
+cmp dist/support-reply.rlpack dist/pulled-support-reply.rlpack
+```
+
+Once vetting passes and hosted execution is approved for that exact digest:
+
+```bash
+rubricloop run \
+  YOUR_NAMESPACE/support-reply@sha256:BUNDLE_DIGEST \
+  --input sdk/examples/verify_reply_registry/run-input.json
+```
+
+No credential belongs in this folder. `login` reads the key without echoing it
+and stores it in the operating system keychain.

rubricloop-0.1.4/examples/verify_reply_registry/build_package.py

@@ -0,0 +1,122 @@
+"""Build the registry package used by the OpenAI reply Quick Start."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from rubricloop import build_rlpack, create_manifest, read_rlpack
+
+VALID_REPLY = (
+    "We apologize for the delay with your order. Our team is currently investigating "
+    "the issue and working to resolve it as quickly as possible. You can expect an "
+    "update on the timeline for your order shortly. Thank you for your patience."
+)
+
+
+def manifest(namespace: str, version: str) -> dict:
+    golden = [
+        {
+            "id": f"valid-reply-{index:02d}",
+            "input": {"reply": VALID_REPLY},
+            "context": {},
+            "expected": {"decision": "allow"},
+        }
+        for index in range(1, 21)
+    ]
+    return create_manifest(
+        namespace=namespace,
+        name="support-reply",
+        version=version,
+        title="Support reply",
+        description="Checks reply length, timeline wording, and refund promises.",
+        license="MIT",
+        categories=("Support", "Safety"),
+        rules=(
+            {
+                "id": "reply.length",
+                "kind": "text.word_count",
+                "severity": "error",
+                "description": "Reply must contain 40 to 70 words.",
+                "config": {"field": "reply", "minimum": 40, "maximum": 70},
+            },
+            {
+                "id": "reply.timeline",
+                "kind": "text.required_terms",
+                "severity": "error",
+                "description": "Reply must explain the timeline.",
+                "config": {"field": "reply", "terms": ["timeline"]},
+            },
+            {
+                "id": "reply.promise",
+                "kind": "text.forbidden_terms",
+                "severity": "error",
+                "description": "Reply must not promise a guaranteed refund.",
+                "config": {"field": "reply", "terms": ["guaranteed refund"]},
+            },
+        ),
+        tests={
+            "golden": golden,
+            "mutation": [
+                {
+                    "id": "forbidden-refund-promise",
+                    "input": {"reply": "We offer a guaranteed refund."},
+                    "context": {},
+                    "expected": {"decision": "deny"},
+                }
+            ],
+            "fail_closed": [
+                {
+                    "id": "missing-reply",
+                    "input": {},
+                    "context": {},
+                    "expected": {"decision": "deny"},
+                }
+            ],
+        },
+        examples=(
+            {
+                "name": "delayed-order",
+                "input": {"reply": VALID_REPLY},
+                "context": {},
+            },
+        ),
+        provenance={
+            "builder": "rubricloop-sdk",
+            "source_repository": "https://rubricloop.com/docs",
+            "source_revision": "verify-reply-quick-start",
+            "built_at": "",
+        },
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--namespace", required=True)
+    parser.add_argument("--version", default="1.0.0")
+    parser.add_argument("--output", type=Path, default=Path("dist/support-reply.rlpack"))
+    args = parser.parse_args()
+
+    bundle = build_rlpack(
+        manifest(args.namespace, args.version),
+        {
+            "payload/quick-start.json": json.dumps(
+                {
+                    "example": "sdk/examples/verify_reply.py",
+                    "model": "gpt-4o-mini",
+                },
+                sort_keys=True,
+            ).encode()
+        },
+    )
+    package = read_rlpack(bundle)
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_bytes(bundle)
+    print(args.output)
+    print(package.manifest_digest)
+    print(package.archive_digest)
+
+
+if __name__ == "__main__":
+    main()

rubricloop-0.1.4/examples/verify_reply_registry/run-input.json

@@ -0,0 +1,6 @@
+{
+  "output": {
+    "reply": "We apologize for the delay with your order. Our team is currently investigating the issue and working to resolve it as quickly as possible. You can expect an update on the timeline for your order shortly. Thank you for your patience."
+  },
+  "context": {}
+}

{rubricloop-0.1.2 → rubricloop-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rubricloop"
-version = "0.1.2"
+version = "0.1.4"
 description = "Bounded, auditable verification loops for AI agent output."
 readme = "README.md"
 requires-python = ">=3.10"

{rubricloop-0.1.2 → rubricloop-0.1.4}/src/rubricloop/__init__.py

@@ -56,4 +56,4 @@ __all__ = [
     "verify",
 ]
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"

{rubricloop-0.1.2 → rubricloop-0.1.4}/src/rubricloop/cli.py

@@ -23,12 +23,16 @@ from .rlpack import RlpackError, read_rlpack
 
 def parser() -> argparse.ArgumentParser:
     root = argparse.ArgumentParser(prog="rubricloop")
-    root.add_argument("--server", default=DEFAULT_SERVER)
+    root.add_argument("--server", default=DEFAULT_SERVER, help=argparse.SUPPRESS)
     commands = root.add_subparsers(dest="command", required=True)
     login = commands.add_parser("login")
     login.add_argument("--api-key")
     init = commands.add_parser("init")
     init.add_argument("directory", nargs="?", default=".")
+    create = commands.add_parser("create")
+    create.add_argument("repository")
+    create.add_argument("--description", default="")
+    create.add_argument("--visibility", choices=("public", "private"), default="private")
     for command in ("validate", "test"):
         item = commands.add_parser(command)
         item.add_argument("package")
@@ -89,6 +93,20 @@ def execute(args: argparse.Namespace) -> dict | str:
             + "\n"
         )
         return str(target)
+    if args.command == "create":
+        namespace, slash, name = args.repository.partition("/")
+        if not slash or not namespace or not name or "/" in name:
+            raise RegistryClientError("repository must be namespace/name")
+        return client.json(
+            "POST",
+            "/v1/registry/repositories",
+            payload={
+                "namespace": namespace,
+                "name": name,
+                "description": args.description,
+                "visibility": args.visibility,
+            },
+        )
     if args.command in {"validate", "test"}:
         package = _package(args.package)
         if args.command == "validate":

{rubricloop-0.1.2 → rubricloop-0.1.4}/src/rubricloop/packs/__init__.py

@@ -16,7 +16,7 @@ from .refund import (
 )
 from .security import CVE_SCHEMA_VERSION, check_cve_record
 from .sql import sql_safe
-from .support import check_support_agent
+from .support import check_support_agent, check_support_reply
 
 __all__ = [
     "CVE_SCHEMA_VERSION",
@@ -37,6 +37,7 @@ __all__ = [
     "check_refund",
     "check_shipment_docs",
     "check_support_agent",
+    "check_support_reply",
     "official_manifest",
     "official_packages",
     "refund_policy_pack",

{rubricloop-0.1.2 → rubricloop-0.1.4}/src/rubricloop/packs/catalog.py

@@ -32,6 +32,13 @@ SUPPORT_CONTEXT = {
     },
     "now": "2026-09-23T09:00:00Z",
 }
+SUPPORT_REPLY_OUTPUT = {
+    "reply": (
+        "We apologize for the delay with your order. Our team is currently investigating "
+        "the issue and working to resolve it as quickly as possible. You can expect an "
+        "update on the timeline for your order shortly. Thank you for your patience."
+    )
+}
 
 COMMERCE_OUTPUT = {
     "quote_id": "Q-100",
@@ -118,6 +125,18 @@ SQL_OUTPUT = {"query": "SELECT name FROM users WHERE country = 'DE'"}
 SQL_CONTEXT = {"scenario": "users-by-country"}
 
 PACKS = (
+    PackMetadata(
+        id="support/reply-v1",
+        version="1",
+        name="Support reply",
+        description="Checks reply length, timeline wording, and unsupported refund promises.",
+        category="Support",
+        tier="oss",
+        status="preview",
+        execution="gate_only",
+        input_example=SUPPORT_REPLY_OUTPUT,
+        context_example={},
+    ),
     PackMetadata(
         id="support/agent-v1",
         version="1",

{rubricloop-0.1.2 → rubricloop-0.1.4}/src/rubricloop/packs/support.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import re
 from datetime import datetime
 from typing import Any
 
@@ -9,6 +10,40 @@ from ..checks.structured import text_contains_all
 from .base import PackCheck, PackResult
 from .refund import RefundOrder, RefundPolicy, check_refund
 
+_WORD = re.compile(r"\b[\w'-]+\b", re.UNICODE)
+
+
+def check_support_reply(output: dict[str, Any], context: dict[str, Any]) -> PackResult:
+    """Check the same reply rules used by the public Quick Start."""
+    del context
+    checks = PackCheck()
+    reply = output.get("reply")
+    text = reply if isinstance(reply, str) else ""
+    word_count = len(_WORD.findall(text))
+
+    checks.require(
+        40 <= word_count <= 70,
+        rule_id="reply.length",
+        name="reply length",
+        evidence=f"reply contains {word_count} words; expected 40 to 70",
+        hint="write a reply containing 40 to 70 words",
+    )
+    checks.require(
+        "timeline" in text.casefold(),
+        rule_id="reply.timeline",
+        name="timeline wording",
+        evidence="reply does not contain the word timeline",
+        hint="explain the timeline in the reply",
+    )
+    checks.require(
+        "guaranteed refund" not in text.casefold(),
+        rule_id="reply.promise",
+        name="refund promise",
+        evidence="reply contains the forbidden phrase guaranteed refund",
+        hint="remove the unsupported refund promise",
+    )
+    return checks.result(output, metrics={"word_count": word_count})
+
 
 def check_support_agent(output: dict[str, Any], context: dict[str, Any]) -> PackResult:
     checks = PackCheck()

{rubricloop-0.1.2 → rubricloop-0.1.4}/src/rubricloop/registry.py

@@ -14,7 +14,7 @@ from urllib.parse import urlsplit
 from .rlpack import read_rlpack
 
 KEYCHAIN_SERVICE = "com.rubricloop.registry"
-DEFAULT_SERVER = "http://localhost:8080"
+DEFAULT_SERVER = "https://api.rubricloop.dev"
 LOCKFILE = "rubricloop.lock"
 
 

{rubricloop-0.1.2 → rubricloop-0.1.4}/tests/test_registry_cli.py

@@ -6,6 +6,7 @@ import pytest
 
 from rubricloop.cli import execute, parser
 from rubricloop.registry import (
+    DEFAULT_SERVER,
     RegistryClient,
     RegistryClientError,
     load_credential,
@@ -15,8 +16,25 @@ from rubricloop.registry import (
 )
 
 
+def test_cli_defaults_to_hosted_registry():
+    assert DEFAULT_SERVER == "https://api.rubricloop.dev"
+    assert parser().parse_args(["login"]).server == DEFAULT_SERVER
+    assert "--server" not in parser().format_help()
+
+
 def test_cli_exposes_complete_lifecycle():
-    for command in ("login", "init", "validate", "test", "push", "vet", "publish", "pull", "run"):
+    for command in (
+        "login",
+        "init",
+        "create",
+        "validate",
+        "test",
+        "push",
+        "vet",
+        "publish",
+        "pull",
+        "run",
+    ):
         assert command in parser()._subparsers._group_actions[0].choices
 
 
@@ -26,6 +44,42 @@ def test_init_creates_project_without_credentials(tmp_path):
     assert json.loads((tmp_path / "rubricloop.json").read_text())["format_version"] == 1
 
 
+def test_create_calls_repository_endpoint(monkeypatch):
+    calls = []
+    monkeypatch.setattr(
+        RegistryClient,
+        "json",
+        lambda self, method, path, **kwargs: calls.append((method, path, kwargs)) or {"id": "repo"},
+    )
+    result = execute(
+        parser().parse_args(
+            [
+                "create",
+                "acme/reply-check",
+                "--visibility",
+                "public",
+                "--description",
+                "Checks support replies.",
+            ]
+        )
+    )
+    assert result == {"id": "repo"}
+    assert calls == [
+        (
+            "POST",
+            "/v1/registry/repositories",
+            {
+                "payload": {
+                    "namespace": "acme",
+                    "name": "reply-check",
+                    "description": "Checks support replies.",
+                    "visibility": "public",
+                }
+            },
+        )
+    ]
+
+
 def test_credentials_use_keychain_or_explicit_environment(monkeypatch):
     values = {}
     backend_type = type("Backend", (), {})

{rubricloop-0.1.2 → rubricloop-0.1.4}/tests/test_wave_one_packs.py

@@ -9,6 +9,7 @@ from rubricloop.packs import (
     check_quote_invoice,
     check_shipment_docs,
     check_support_agent,
+    check_support_reply,
 )
 from rubricloop.packs.catalog import (
     COMMERCE_CONTEXT,
@@ -31,6 +32,32 @@ def test_support_golden_set(case):
     assert check_support_agent(output, deepcopy(SUPPORT_CONTEXT)).decision == "allow"
 
 
+def test_support_reply_matches_quick_start_rules():
+    valid = check_support_reply(
+        {
+            "reply": (
+                "We apologize for the delay with your order. Our team is currently "
+                "investigating the issue and working to resolve it as quickly as possible. "
+                "You can expect an update on the timeline for your order shortly. Thank "
+                "you for your patience."
+            )
+        },
+        {},
+    )
+    invalid = check_support_reply(
+        {"reply": "We promise a guaranteed refund and will update you soon."},
+        {},
+    )
+
+    assert valid.decision == "allow"
+    assert invalid.decision == "deny"
+    assert {failure.rule_id for failure in invalid.failures} == {
+        "reply.length",
+        "reply.timeline",
+        "reply.promise",
+    }
+
+
 @pytest.mark.parametrize("case", range(20))
 def test_commerce_golden_set(case):
     output = deepcopy(COMMERCE_OUTPUT)