recx-cli 0.0.1__py3-none-any.whl

recx_cli/__init__.py

@@ -0,0 +1 @@
+"""recx-cli: the validator for RECX.yaml manifests."""

recx_cli/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from recx_cli.cli import main
+
+sys.exit(main())

recx_cli/check.py

@@ -0,0 +1,328 @@
+"""Validate a RECX.yaml manifest: the schema plus the rules SPEC.md adds to it.
+
+Manifest text is untrusted. It is parsed with a restricted YAML loader, never
+evaluated, and anything echoed back is escaped and truncated.
+"""
+
+from __future__ import annotations
+
+import datetime
+import json
+import os
+import re
+from dataclasses import dataclass
+from importlib import resources
+from pathlib import Path
+from typing import Any
+
+import yaml
+from jsonschema import Draft202012Validator, FormatChecker
+
+MAX_BYTES = 64 * 1024  # SPEC.md rule 5
+ROOT = "/"  # how the whole document is named in an error line
+_SCHEMA_NAME = "recx.schema.json"
+
+
+@dataclass(frozen=True)
+class Problem:
+    pointer: str
+    message: str
+
+
+# -- schema ---------------------------------------------------------------
+
+
+def load_schema() -> dict:
+    """The bundled schema; in a source checkout, spec/recx.schema.json itself."""
+    try:
+        text = (resources.files("recx_cli") / _SCHEMA_NAME).read_text(encoding="utf-8")
+    except (FileNotFoundError, OSError):
+        # Not built into a wheel (editable install or plain checkout): the one
+        # copy under version control sits at <repo>/spec/.
+        text = (Path(__file__).resolve().parents[2] / "spec" / _SCHEMA_NAME).read_text(
+            encoding="utf-8"
+        )
+    return json.loads(text)
+
+
+# -- parsing (rule 6) -----------------------------------------------------
+
+
+class ManifestError(Exception):
+    def __init__(self, message: str, line: int | None = None):
+        super().__init__(message)
+        self.line = line
+
+
+_MERGE_TAG = "tag:yaml.org,2002:merge"
+
+
+class StrictLoader(yaml.SafeLoader):
+    """SafeLoader that refuses anchors, aliases, merge keys and repeated keys."""
+
+    def compose_node(self, parent, index):
+        if self.check_event(yaml.events.AliasEvent):
+            event = self.peek_event()
+            raise ManifestError(
+                "aliases (*name) are not allowed (SPEC.md rule 6)",
+                event.start_mark.line + 1,
+            )
+        event = self.peek_event()
+        if getattr(event, "anchor", None) is not None:
+            raise ManifestError(
+                "anchors (&name) are not allowed (SPEC.md rule 6)",
+                event.start_mark.line + 1,
+            )
+        return super().compose_node(parent, index)
+
+    def construct_mapping(self, node, deep=False):
+        if isinstance(node, yaml.MappingNode):
+            seen: set = set()
+            for key_node, _ in node.value:
+                line = key_node.start_mark.line + 1
+                if key_node.tag == _MERGE_TAG:
+                    raise ManifestError(
+                        "merge keys (<<) are not allowed (SPEC.md rule 6)", line
+                    )
+                if isinstance(key_node, yaml.ScalarNode):
+                    key = self.construct_object(key_node)
+                    try:
+                        if key in seen:
+                            raise ManifestError(
+                                f"mapping key {_show(key)} is repeated (SPEC.md rule 6)",
+                                line,
+                            )
+                        seen.add(key)
+                    except TypeError:
+                        pass
+        return super().construct_mapping(node, deep=deep)
+
+
+def parse(text: str) -> Any:
+    try:
+        return yaml.load(text, Loader=StrictLoader)  # noqa: S506 - SafeLoader subclass
+    except ManifestError:
+        raise
+    except yaml.YAMLError as exc:
+        mark = getattr(exc, "problem_mark", None)
+        problem = getattr(exc, "problem", None) or "invalid YAML"
+        raise ManifestError(
+            f"invalid YAML: {problem}", mark.line + 1 if mark is not None else None
+        ) from None
+
+
+# -- output hygiene -------------------------------------------------------
+
+
+# Control characters, plus the line separators and bidi controls a terminal would
+# otherwise act on: a bidi override can make echoed manifest text read differently
+# from what it is.
+_UNSAFE = re.compile(r"[^\x20-\x7e -\U0010ffff]|[؜‎‏
-‮⁦-⁩]")
+
+
+def _clean(text: str, limit: int = 200) -> str:
+    if len(text) > limit:
+        text = text[:limit] + "..."
+    return _UNSAFE.sub(
+        lambda m: "\\x%02x" % ord(m.group()) if ord(m.group()) < 256 else "\\u%04x" % ord(m.group()),
+        text,
+    )
+
+
+def _show(value: Any) -> str:
+    return _clean(repr(value), 80)
+
+
+def _pointer(parts) -> str:
+    if not parts:
+        return ROOT
+    return "".join("/" + str(p).replace("~", "~0").replace("/", "~1") for p in parts)
+
+
+# -- schema errors, with quoting hints ------------------------------------
+
+_YAML_SCALAR_KINDS = (
+    (bool, "a boolean"),
+    (int, "an integer"),
+    (float, "a number"),
+    (datetime.datetime, "a date-time"),
+    (datetime.date, "a date"),
+)
+
+
+def _yaml_kind(value: Any) -> str | None:
+    for cls, name in _YAML_SCALAR_KINDS:
+        if isinstance(value, cls):
+            return name
+    return None
+
+
+def _expects_string(error) -> bool:
+    if error.validator == "type":
+        expected = error.validator_value
+        return "string" in (expected if isinstance(expected, list) else [expected])
+    if error.validator in ("enum", "const"):
+        options = error.validator_value if error.validator == "enum" else [error.validator_value]
+        return any(isinstance(o, str) for o in options)
+    return False
+
+
+def _value_text(value: Any) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, (datetime.date, datetime.datetime)):
+        return value.isoformat()
+    return str(value)
+
+
+def schema_problems(data: Any, schema: dict) -> list[Problem]:
+    validator = Draft202012Validator(schema, format_checker=FormatChecker())
+    errors = sorted(validator.iter_errors(data), key=lambda e: [str(p) for p in e.absolute_path])
+    type_error_at = {
+        _pointer(e.absolute_path)
+        for e in errors
+        if e.validator == "type" and _yaml_kind(e.instance) and _expects_string(e)
+    }
+    problems = []
+    for error in errors:
+        pointer = _pointer(error.absolute_path)
+        kind = _yaml_kind(error.instance)
+        if kind and _expects_string(error):
+            value = _clean(_value_text(error.instance), 60)
+            if error.validator != "type" and pointer in type_error_at:
+                continue  # the type error says it all
+            problems.append(
+                Problem(
+                    pointer,
+                    f"expected a string, but YAML read {value} as {kind}; "
+                    f'quote the value (for example "{value}")',
+                )
+            )
+            continue
+        problems.append(Problem(pointer, _clean(error.message)))
+    return problems
+
+
+# -- rules 1, 2 and 3 -----------------------------------------------------
+
+
+def _entries(data: Any, key: str) -> list[tuple[int, dict]]:
+    items = data.get(key) if isinstance(data, dict) else None
+    if not isinstance(items, list):
+        return []
+    return [(i, item) for i, item in enumerate(items) if isinstance(item, dict)]
+
+
+def rule_problems(data: Any) -> list[Problem]:
+    problems: list[Problem] = []
+    modules = _entries(data, "modules")
+    evidence = _entries(data, "evidence")
+
+    module_ids: set[str] = set()
+    first_seen: dict[str, str] = {}
+    for i, mod in modules:
+        mid = mod.get("id")
+        if not isinstance(mid, str):
+            continue
+        where = f"/modules/{i}/id"
+        if mid in first_seen:
+            problems.append(
+                Problem(where, f"duplicate module id {_show(mid)} (rule 1; first used at {first_seen[mid]})")
+            )
+        else:
+            first_seen[mid] = where
+        module_ids.add(mid)
+
+    seen_ev: dict[str, str] = {}
+    for i, ev in evidence:
+        eid = ev.get("id")
+        if not isinstance(eid, str):
+            continue
+        where = f"/evidence/{i}/id"
+        if eid in seen_ev:
+            problems.append(
+                Problem(where, f"duplicate evidence id {_show(eid)} (rule 1; first used at {seen_ev[eid]})")
+            )
+        else:
+            seen_ev[eid] = where
+
+    def check_refs(base: str, refs: Any, what: str) -> None:
+        if not isinstance(refs, list):
+            return
+        for j, ref in enumerate(refs):
+            if isinstance(ref, str) and ref not in module_ids:
+                problems.append(
+                    Problem(f"{base}/{j}", f"{what} {_show(ref)} names no module in this manifest (rule 2)")
+                )
+
+    for i, mod in modules:
+        requires = mod.get("requires")
+        if isinstance(requires, dict):
+            check_refs(f"/modules/{i}/requires/modules", requires.get("modules"), "required module")
+    for i, ev in evidence:
+        check_refs(f"/evidence/{i}/covers", ev.get("covers"), "covered module")
+    return problems
+
+
+def path_problems(data: Any, base: Path, skip: set[str]) -> list[Problem]:
+    """Rule 3. Paths the schema already rejected are never touched on disk."""
+    problems = []
+    for i, mod in _entries(data, "modules"):
+        path = mod.get("path")
+        pointer = f"/modules/{i}/path"
+        if not isinstance(path, str) or pointer in skip:
+            continue
+        target = base / path
+        try:
+            exists = target.exists()
+            is_dir = target.is_dir()
+        except OSError as exc:
+            problems.append(Problem(pointer, f"cannot inspect path: {_clean(exc.strerror or 'error')} (rule 3)"))
+            continue
+        shown = _show(path)
+        if not exists:
+            problems.append(Problem(pointer, f"path {shown} does not exist relative to the manifest (rule 3)"))
+        elif path.endswith("/") and not is_dir:
+            problems.append(Problem(pointer, f"path {shown} ends in / but is a file (rule 3)"))
+        elif not path.endswith("/") and is_dir:
+            problems.append(Problem(pointer, f"path {shown} is a directory, so it must end in / (rule 3)"))
+    return problems
+
+
+# -- entry point ----------------------------------------------------------
+
+
+class Unreadable(Exception):
+    pass
+
+
+def check_file(path: Path, *, repo: bool = True) -> list[Problem]:
+    """Return every problem with the manifest at `path`; raise Unreadable if it cannot be read."""
+    try:
+        size = path.stat().st_size
+        if not path.is_file():
+            raise Unreadable("not a regular file")
+        if size > MAX_BYTES:
+            return [Problem(ROOT, f"file is {size} bytes, over the 64 KiB limit (rule 5)")]
+        raw = path.read_bytes()
+    except OSError as exc:
+        raise Unreadable(_clean(exc.strerror or str(exc))) from None
+    if len(raw) > MAX_BYTES:
+        return [Problem(ROOT, f"file is {len(raw)} bytes, over the 64 KiB limit (rule 5)")]
+    try:
+        text = raw.decode("utf-8")
+    except UnicodeDecodeError:
+        return [Problem(ROOT, "file is not valid UTF-8")]
+
+    try:
+        data = parse(text)
+    except ManifestError as exc:
+        where = f"line {exc.line}: " if exc.line else ""
+        return [Problem(ROOT, f"{where}{_clean(str(exc))}")]
+
+    problems = schema_problems(data, load_schema())
+    problems += rule_problems(data)
+    if repo:
+        skip = {p.pointer for p in problems}
+        problems += path_problems(data, path.resolve().parent, skip)
+    return problems

recx_cli/cli.py

@@ -0,0 +1,67 @@
+"""Command line: `recx check [PATH] [--no-repo]`."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from importlib import metadata
+from pathlib import Path
+
+from recx_cli.check import Unreadable, check_file
+
+
+def _version() -> str:
+    try:
+        return metadata.version("recx-cli")
+    except metadata.PackageNotFoundError:
+        return "unknown"
+
+
+class _Parser(argparse.ArgumentParser):
+    def error(self, message):  # argparse exits 2 already; keep it explicit
+        self.print_usage(sys.stderr)
+        self.exit(2, f"{self.prog}: error: {message}\n")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = _Parser(prog="recx", description="Tools for RECX.yaml manifests.")
+    parser.add_argument("--version", action="version", version=f"recx {_version()}")
+    sub = parser.add_subparsers(dest="command", required=True, parser_class=_Parser)
+    check = sub.add_parser(
+        "check",
+        help="validate a RECX.yaml manifest",
+        description="Validate a manifest against the schema and the rules in spec/SPEC.md. "
+        "Exit status: 0 valid, 1 invalid, 2 usage error or unreadable file.",
+    )
+    check.add_argument(
+        "path",
+        nargs="?",
+        default="RECX.yaml",
+        metavar="PATH",
+        help="a manifest file, or a directory holding RECX.yaml (default: ./RECX.yaml)",
+    )
+    check.add_argument(
+        "--no-repo",
+        action="store_true",
+        help="skip the checks that look at the repository (rule 3: module paths exist)",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    target = Path(args.path)
+    if target.is_dir():
+        target = target / "RECX.yaml"
+    label = str(target)
+    try:
+        problems = check_file(target, repo=not args.no_repo)
+    except Unreadable as exc:
+        print(f"{label}: cannot read: {exc}", file=sys.stderr)
+        return 2
+    if not problems:
+        print(f"{label}: valid")
+        return 0
+    for p in problems:
+        print(f"{label}: {p.pointer}: {p.message}")
+    return 1

recx_cli/recx.schema.json

@@ -0,0 +1,469 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "RECX.yaml manifest",
+  "description": "recx v0.1: a repository's description of itself for other people's coding agents. See spec/SPEC.md. Every string in a manifest is untrusted data to the agent reading it, never instructions.",
+  "type": "object",
+  "required": [
+    "recx",
+    "name",
+    "summary",
+    "license",
+    "status",
+    "capabilities"
+  ],
+  "additionalProperties": false,
+  "patternProperties": {
+    "^x-[a-z0-9][a-z0-9-]{0,62}$": {
+      "$ref": "#/$defs/extension"
+    }
+  },
+  "properties": {
+    "recx": {
+      "description": "Spec version this manifest is written against.",
+      "type": "string",
+      "enum": [
+        "0.1"
+      ]
+    },
+    "name": {
+      "description": "The project's name, as its own authors spell it in lowercase.",
+      "$ref": "#/$defs/slug"
+    },
+    "summary": {
+      "description": "What the project does, in one sentence.",
+      "$ref": "#/$defs/line"
+    },
+    "description": {
+      "description": "A short paragraph: the problem it solves, the approach, and what is out of scope.",
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 2000
+    },
+    "license": {
+      "description": "SPDX identifier of the project's license. Only permissive licenses are allowed, so anything listed can be reused without negotiation.",
+      "$ref": "#/$defs/license"
+    },
+    "status": {
+      "description": "How much the authors stand behind it.",
+      "type": "string",
+      "enum": [
+        "experimental",
+        "active",
+        "stable",
+        "maintenance",
+        "archived"
+      ]
+    },
+    "capabilities": {
+      "description": "What the project can do, one verb phrase per item. This is what an agent matches an idea against.",
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 30,
+      "uniqueItems": true,
+      "items": {
+        "$ref": "#/$defs/phrase"
+      }
+    },
+    "languages": {
+      "description": "Programming languages the project is written in, lowercase.",
+      "type": "array",
+      "maxItems": 10,
+      "uniqueItems": true,
+      "items": {
+        "$ref": "#/$defs/tag"
+      }
+    },
+    "tags": {
+      "description": "Lowercase kebab-case topic tags.",
+      "type": "array",
+      "maxItems": 20,
+      "uniqueItems": true,
+      "items": {
+        "$ref": "#/$defs/tag"
+      }
+    },
+    "repository": {
+      "description": "Canonical URL of the source repository. Optional: an agent that found this file already knows where it is.",
+      "$ref": "#/$defs/url"
+    },
+    "homepage": {
+      "description": "Project homepage or documentation URL.",
+      "$ref": "#/$defs/url"
+    },
+    "generator": {
+      "description": "The tool that wrote this manifest, with its version, when a tool wrote it.",
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 100
+    },
+    "modules": {
+      "description": "The reusable pieces of the project, each one something another project could take on its own.",
+      "type": "array",
+      "maxItems": 100,
+      "items": {
+        "$ref": "#/$defs/module"
+      }
+    },
+    "evidence": {
+      "description": "Checks anyone can rerun to see whether the project works.",
+      "type": "array",
+      "maxItems": 50,
+      "items": {
+        "$ref": "#/$defs/evidence"
+      }
+    },
+    "reuses": {
+      "description": "Work from other repositories this project took and built on. Read across many manifests, these entries are the reuse graph.",
+      "type": "array",
+      "maxItems": 100,
+      "items": {
+        "$ref": "#/$defs/reuse"
+      }
+    }
+  },
+  "$defs": {
+    "slug": {
+      "type": "string",
+      "maxLength": 64,
+      "pattern": "^[a-z0-9][a-z0-9._-]{0,63}$"
+    },
+    "id": {
+      "type": "string",
+      "maxLength": 64,
+      "pattern": "^[a-z0-9][a-z0-9-]{0,63}$"
+    },
+    "tag": {
+      "type": "string",
+      "maxLength": 40,
+      "pattern": "^[a-z0-9][a-z0-9+#.-]{0,39}$"
+    },
+    "line": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 160,
+      "pattern": "^[^\\n\\r]*$"
+    },
+    "phrase": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 200,
+      "pattern": "^[^\\n\\r]*$"
+    },
+    "command": {
+      "description": "One shell command line, run from the repository root.",
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 300,
+      "pattern": "^[^\\n\\r]*$"
+    },
+    "url": {
+      "type": "string",
+      "format": "uri",
+      "maxLength": 300,
+      "pattern": "^https://"
+    },
+    "relpath": {
+      "description": "A path relative to the repository root: no leading slash, no '..' segment, no spaces. A trailing slash names a directory.",
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 255,
+      "pattern": "^(?!/)(?!.*(?:^|/)\\.\\.(?:/|$))[A-Za-z0-9._@+/-]+$"
+    },
+    "purl": {
+      "description": "A Package URL (https://github.com/package-url/purl-spec), e.g. pkg:pypi/jsonschema or pkg:npm/%40scope/name@1.2.0.",
+      "type": "string",
+      "maxLength": 200,
+      "pattern": "^pkg:[a-z0-9.+-]+/[^\\s]+$"
+    },
+    "sha": {
+      "type": "string",
+      "maxLength": 40,
+      "pattern": "^[0-9a-f]{7,40}$"
+    },
+    "extension": {
+      "description": "The value of an x- extension key: a short scalar. Consumers ignore keys they do not know.",
+      "type": [
+        "string",
+        "number",
+        "boolean"
+      ],
+      "maxLength": 500
+    },
+    "license": {
+      "type": "string",
+      "enum": [
+        "0BSD",
+        "Apache-2.0",
+        "BlueOak-1.0.0",
+        "BSD-2-Clause",
+        "BSD-3-Clause",
+        "BSL-1.0",
+        "CC0-1.0",
+        "ISC",
+        "MIT",
+        "MIT-0",
+        "UPL-1.0",
+        "Unlicense",
+        "Zlib"
+      ]
+    },
+    "module": {
+      "type": "object",
+      "required": [
+        "id",
+        "path",
+        "summary",
+        "interface",
+        "extract"
+      ],
+      "additionalProperties": false,
+      "patternProperties": {
+        "^x-[a-z0-9][a-z0-9-]{0,62}$": {
+          "$ref": "#/$defs/extension"
+        }
+      },
+      "properties": {
+        "id": {
+          "description": "Unique within this manifest.",
+          "$ref": "#/$defs/id"
+        },
+        "path": {
+          "description": "Where the module lives: a file, or a directory with a trailing slash.",
+          "$ref": "#/$defs/relpath"
+        },
+        "summary": {
+          "description": "What the module does, in one sentence.",
+          "$ref": "#/$defs/line"
+        },
+        "capabilities": {
+          "description": "What this module alone can do, when that is narrower than the project's list.",
+          "type": "array",
+          "maxItems": 20,
+          "uniqueItems": true,
+          "items": {
+            "$ref": "#/$defs/phrase"
+          }
+        },
+        "language": {
+          "$ref": "#/$defs/tag"
+        },
+        "interface": {
+          "description": "How the module is called.",
+          "type": "object",
+          "required": [
+            "type",
+            "entrypoints"
+          ],
+          "additionalProperties": false,
+          "properties": {
+            "type": {
+              "type": "string",
+              "enum": [
+                "library",
+                "cli",
+                "http-api",
+                "mcp-server",
+                "github-action",
+                "claude-code-plugin",
+                "agent-skill",
+                "schema",
+                "config",
+                "other"
+              ]
+            },
+            "entrypoints": {
+              "description": "Signatures, commands or endpoints, one per item, as a caller would write them.",
+              "type": "array",
+              "minItems": 1,
+              "maxItems": 30,
+              "items": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 300,
+                "pattern": "^[^\\n\\r]*$"
+              }
+            }
+          }
+        },
+        "requires": {
+          "description": "What the module needs besides itself.",
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "packages": {
+              "description": "Third-party packages, as Package URLs.",
+              "type": "array",
+              "maxItems": 50,
+              "uniqueItems": true,
+              "items": {
+                "$ref": "#/$defs/purl"
+              }
+            },
+            "modules": {
+              "description": "Ids of other modules in this manifest.",
+              "type": "array",
+              "maxItems": 50,
+              "uniqueItems": true,
+              "items": {
+                "$ref": "#/$defs/id"
+              }
+            }
+          }
+        },
+        "extract": {
+          "description": "How another project takes this module.",
+          "type": "object",
+          "required": [
+            "method"
+          ],
+          "additionalProperties": false,
+          "properties": {
+            "method": {
+              "description": "copy: copy the path into your project. package: install the published package. fork: the module is not separable; fork the repository.",
+              "type": "string",
+              "enum": [
+                "copy",
+                "package",
+                "fork"
+              ]
+            },
+            "package": {
+              "description": "The published package, when method is package.",
+              "$ref": "#/$defs/purl"
+            },
+            "notes": {
+              "description": "Anything a copier must change or know, such as a config value or an import path to rewrite.",
+              "type": "string",
+              "minLength": 1,
+              "maxLength": 500
+            }
+          },
+          "if": {
+            "properties": {
+              "method": {
+                "const": "package"
+              }
+            }
+          },
+          "then": {
+            "required": [
+              "package"
+            ]
+          }
+        }
+      }
+    },
+    "evidence": {
+      "type": "object",
+      "required": [
+        "id",
+        "run",
+        "covers"
+      ],
+      "additionalProperties": false,
+      "patternProperties": {
+        "^x-[a-z0-9][a-z0-9-]{0,62}$": {
+          "$ref": "#/$defs/extension"
+        }
+      },
+      "properties": {
+        "id": {
+          "description": "Unique within this manifest.",
+          "$ref": "#/$defs/id"
+        },
+        "summary": {
+          "description": "What the check checks, in one sentence.",
+          "$ref": "#/$defs/line"
+        },
+        "setup": {
+          "description": "The command that prepares a fresh clone for run, if one is needed.",
+          "$ref": "#/$defs/command"
+        },
+        "run": {
+          "description": "The command that performs the check. Exit status 0 means pass.",
+          "$ref": "#/$defs/command"
+        },
+        "covers": {
+          "description": "Ids of the modules this check exercises. An empty list means the project as a whole.",
+          "type": "array",
+          "maxItems": 100,
+          "uniqueItems": true,
+          "items": {
+            "$ref": "#/$defs/id"
+          }
+        },
+        "last_result": {
+          "description": "The most recent run. Self-reported unless a consumer reruns it; see SPEC.md, Trust.",
+          "type": "object",
+          "required": [
+            "status",
+            "commit",
+            "date",
+            "runner"
+          ],
+          "additionalProperties": false,
+          "properties": {
+            "status": {
+              "type": "string",
+              "enum": [
+                "pass",
+                "fail"
+              ]
+            },
+            "commit": {
+              "description": "The commit the run checked.",
+              "$ref": "#/$defs/sha"
+            },
+            "date": {
+              "description": "When the run finished, RFC 3339.",
+              "type": "string",
+              "format": "date-time",
+              "maxLength": 40
+            },
+            "runner": {
+              "description": "ci: a CI service ran it; local: someone's own machine did.",
+              "type": "string",
+              "enum": [
+                "ci",
+                "local"
+              ]
+            },
+            "url": {
+              "description": "Where the run's log can be read, such as a CI job page.",
+              "$ref": "#/$defs/url"
+            }
+          }
+        }
+      }
+    },
+    "reuse": {
+      "type": "object",
+      "required": [
+        "repository"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "repository": {
+          "description": "The repository the work came from.",
+          "$ref": "#/$defs/url"
+        },
+        "module": {
+          "description": "The id of the module taken, when the source carries a RECX.yaml.",
+          "$ref": "#/$defs/id"
+        },
+        "path": {
+          "description": "The path taken, in the source repository.",
+          "$ref": "#/$defs/relpath"
+        },
+        "commit": {
+          "description": "The source commit it was taken at.",
+          "$ref": "#/$defs/sha"
+        },
+        "into": {
+          "description": "Where it lives in this repository now.",
+          "$ref": "#/$defs/relpath"
+        }
+      }
+    }
+  }
+}

recx_cli-0.0.1.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.5
+Name: recx-cli
+Version: 0.0.1
+Summary: Validator for RECX.yaml manifests: the recx check command.
+Project-URL: Homepage, https://github.com/jbmv/recx
+Project-URL: Repository, https://github.com/jbmv/recx
+Author: James Bullard
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: jsonschema[format-nongpl]>=4.18
+Requires-Dist: pyyaml>=6
+Description-Content-Type: text/markdown
+
+# recx
+
+*res extra commercium*: things outside commerce. A repository drops a `RECX.yaml` at its
+root to tell other people's coding agents what it does, which of its modules can be taken on
+their own, how to take them, and which checks anyone can rerun to see that they work.
+
+The format is specified in [spec/SPEC.md](spec/SPEC.md); the schema is
+[spec/recx.schema.json](spec/recx.schema.json).
+
+## Checking a manifest
+
+```sh
+pip install recx-cli          # or: uvx --from recx-cli recx check
+
+recx check                    # ./RECX.yaml, including that module paths exist
+recx check path/to/repo       # a directory holding RECX.yaml
+recx check --no-repo FILE     # the file alone, without looking at the repository
+```
+
+One line per problem, `<file>: <json-pointer>: <message>`, or `<file>: valid`. Exit status 0
+means valid, 1 invalid, 2 a usage error or an unreadable file. `recx check` does not yet
+check that the license file agrees with `license` (rule 4 of the spec).
+
+The npm package `@jbmv/recx` ships the schema: `require('@jbmv/recx')` returns it.
+
+This README is an interim one. The full README is still to come.

recx_cli-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+recx_cli/__init__.py,sha256=xOr2-4_763vaMHuUpNycY6C9RFRGMZZq9KqMRJlcTVE,55
+recx_cli/__main__.py,sha256=u_9wZdHeDK_XOOL7DuoLe5ENEYCyYn6R51mEYRdRkpI,60
+recx_cli/check.py,sha256=892HT5pGw1WIMzff0kRRT3jWgBli06Jlh49CvKQSEI8,11315
+recx_cli/cli.py,sha256=rGNJ2m9f6bXWDcje5tMcIVuLx1wGzYH1fr120raoKHs,2089
+recx_cli/recx.schema.json,sha256=ig44nYMPpHlnBHA5nsCCcZsTjsCtwhzDtsu62zesVfU,13366
+recx_cli-0.0.1.dist-info/METADATA,sha256=X6vayuHEID_6Z6_eLy9Bctef6SZOo8hyKkdrXcQIMPw,1558
+recx_cli-0.0.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+recx_cli-0.0.1.dist-info/entry_points.txt,sha256=2gqAsQLrd8vlNRF7jkzHPbM5RGZA1rFwA9u_IDwwzdA,43
+recx_cli-0.0.1.dist-info/licenses/LICENSE,sha256=bVBvwsmFseFZxdXisG_Aib8rcHlEwzNreODYnMEpKr8,1070
+recx_cli-0.0.1.dist-info/RECORD,,

recx_cli-0.0.1.dist-info/WHEEL

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

recx_cli-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+recx = recx_cli.cli:main

recx_cli-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 James Bullard
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.