recx-cli 0.0.2__tar.gz → 0.0.4__tar.gz

recx_cli-0.0.4/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.5
+Name: recx-cli
+Version: 0.0.4
+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 way for agents to find reusable, permissively
+licensed code from solo and small-team projects.
+
+A `RECX.yaml` at the root of a repository tells other people's coding agents what the repository
+does, which parts of it they can take on their own, and which checks show those parts work. recx
+is that format, a validator for it, and a Claude Code plugin that keeps the file current.
+
+## Why
+
+Coding agents have increased the amount of software that individuals and small teams produce.
+Much of it remains internal tooling, and the projects that are published are hard to find among
+the number of new repositories. Evaluating an unfamiliar open-source project also takes time, so
+writing a similar tool is often the quicker option, and comparable tools get written more than
+once.
+
+recx moves that search and evaluation to the agent doing the work, in two parts. The first is
+the manifest: a `RECX.yaml` in each participating repository that describes the project's
+capabilities, its separable modules and their interfaces, and the commands that verify them, in
+a fixed machine-readable form. The second is search: a way for an agent, while planning new
+work, to find manifests with relevant modules, check their evidence, and reuse a module rather
+than write it again, recording where it came from in its own project's manifest.
+
+Taking part is meant to cost a repository little. One prompt produces a complete, valid
+manifest, and the Claude Code plugin checks it whenever a session ends, so it stays valid as
+the code changes. No hosted service is involved, because the fixed filename serves as the index.
+On GitHub, manifests can be found by searching code for `path:/(^|\/)recx\.ya?ml$/i`.
+
+## The manifest
+
+```yaml
+recx: "0.1"
+name: tinyfmt
+summary: Formats byte counts as human-readable strings like 1.2 MB.
+license: MIT
+status: stable
+capabilities:
+  - format a byte count as a human-readable size string
+```
+
+Those six keys are the minimum. The optional parts carry most of the information: modules with
+interfaces and extraction notes, evidence anyone can rerun, and records of what was reused from
+where. [spec/SPEC.md](spec/SPEC.md) defines every field, puts a length limit on every string,
+and sets out how to read a stranger's manifest safely.
+
+Only permissively licensed projects qualify (MIT, Apache-2.0, the BSDs and similar), so
+anything listed can be reused without asking.
+
+## Get started
+
+- **Claude Code:** `/plugin marketplace add jbmv/recx`, then `/plugin install recx@recx`
+  (or, on Claude Code 2.1.275 or later, `/plugin install recx --marketplace jbmv/recx`). Then
+  ask Claude to add a RECX.yaml. A Stop hook keeps the manifest valid; set
+  `RECX_STOP_HOOK=warn` or `off` to soften or disable it.
+- **Any other agent:** paste the prompt in [ADOPT.md](ADOPT.md).
+- **By hand:** start from the example above, then run `uvx --from recx-cli recx check`.
+
+## What's here
+
+| | |
+|---|---|
+| [spec/](spec/) | The spec, its JSON Schema, and valid and invalid example manifests |
+| `recx-cli` on PyPI | `recx check`, the validator (`pip install recx-cli`) |
+| `@jbmv/recx` on npm | The schema and examples, for JavaScript tooling |
+| [plugin/](plugin/) | The Claude Code plugin; this repository is its marketplace |
+| [RECX.yaml](RECX.yaml) | recx's own manifest |
+
+## Status
+
+Experimental. The spec is a v0.1 draft and may change before 1.0; every manifest states the
+version it was written against. `recx check` enforces the whole spec except rule 4, that the
+license file matches `license`. The manifest, the validator and the plugin exist; search, the
+second part described above, is not built yet.
+
+## Kyosei
+
+I built recx for Kyosei, a record-keeping tool for running projects with coding agents. Kyosei
+isn't public yet. It will generate its own RECX.yaml from its records. Nothing in the spec
+depends on Kyosei: it is one client of the spec, like any other tool.
+
+## License
+
+MIT

recx_cli-0.0.4/README.md

@@ -0,0 +1,84 @@
+# recx
+
+*res extra commercium*: things outside commerce. A way for agents to find reusable, permissively
+licensed code from solo and small-team projects.
+
+A `RECX.yaml` at the root of a repository tells other people's coding agents what the repository
+does, which parts of it they can take on their own, and which checks show those parts work. recx
+is that format, a validator for it, and a Claude Code plugin that keeps the file current.
+
+## Why
+
+Coding agents have increased the amount of software that individuals and small teams produce.
+Much of it remains internal tooling, and the projects that are published are hard to find among
+the number of new repositories. Evaluating an unfamiliar open-source project also takes time, so
+writing a similar tool is often the quicker option, and comparable tools get written more than
+once.
+
+recx moves that search and evaluation to the agent doing the work, in two parts. The first is
+the manifest: a `RECX.yaml` in each participating repository that describes the project's
+capabilities, its separable modules and their interfaces, and the commands that verify them, in
+a fixed machine-readable form. The second is search: a way for an agent, while planning new
+work, to find manifests with relevant modules, check their evidence, and reuse a module rather
+than write it again, recording where it came from in its own project's manifest.
+
+Taking part is meant to cost a repository little. One prompt produces a complete, valid
+manifest, and the Claude Code plugin checks it whenever a session ends, so it stays valid as
+the code changes. No hosted service is involved, because the fixed filename serves as the index.
+On GitHub, manifests can be found by searching code for `path:/(^|\/)recx\.ya?ml$/i`.
+
+## The manifest
+
+```yaml
+recx: "0.1"
+name: tinyfmt
+summary: Formats byte counts as human-readable strings like 1.2 MB.
+license: MIT
+status: stable
+capabilities:
+  - format a byte count as a human-readable size string
+```
+
+Those six keys are the minimum. The optional parts carry most of the information: modules with
+interfaces and extraction notes, evidence anyone can rerun, and records of what was reused from
+where. [spec/SPEC.md](spec/SPEC.md) defines every field, puts a length limit on every string,
+and sets out how to read a stranger's manifest safely.
+
+Only permissively licensed projects qualify (MIT, Apache-2.0, the BSDs and similar), so
+anything listed can be reused without asking.
+
+## Get started
+
+- **Claude Code:** `/plugin marketplace add jbmv/recx`, then `/plugin install recx@recx`
+  (or, on Claude Code 2.1.275 or later, `/plugin install recx --marketplace jbmv/recx`). Then
+  ask Claude to add a RECX.yaml. A Stop hook keeps the manifest valid; set
+  `RECX_STOP_HOOK=warn` or `off` to soften or disable it.
+- **Any other agent:** paste the prompt in [ADOPT.md](ADOPT.md).
+- **By hand:** start from the example above, then run `uvx --from recx-cli recx check`.
+
+## What's here
+
+| | |
+|---|---|
+| [spec/](spec/) | The spec, its JSON Schema, and valid and invalid example manifests |
+| `recx-cli` on PyPI | `recx check`, the validator (`pip install recx-cli`) |
+| `@jbmv/recx` on npm | The schema and examples, for JavaScript tooling |
+| [plugin/](plugin/) | The Claude Code plugin; this repository is its marketplace |
+| [RECX.yaml](RECX.yaml) | recx's own manifest |
+
+## Status
+
+Experimental. The spec is a v0.1 draft and may change before 1.0; every manifest states the
+version it was written against. `recx check` enforces the whole spec except rule 4, that the
+license file matches `license`. The manifest, the validator and the plugin exist; search, the
+second part described above, is not built yet.
+
+## Kyosei
+
+I built recx for Kyosei, a record-keeping tool for running projects with coding agents. Kyosei
+isn't public yet. It will generate its own RECX.yaml from its records. Nothing in the spec
+depends on Kyosei: it is one client of the spec, like any other tool.
+
+## License
+
+MIT

{recx_cli-0.0.2 → recx_cli-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "recx-cli"
-version = "0.0.2"
+version = "0.0.4"
 description = "Validator for RECX.yaml manifests: the recx check command."
 readme = "README.md"
 requires-python = ">=3.10"

{recx_cli-0.0.2 → recx_cli-0.0.4}/spec/SPEC.md

@@ -7,11 +7,11 @@ written against, so a change never silently reinterprets an old file.
 
 ## Purpose
 
-A great deal of permissively licensed code is being written by people working alone, and much
-of it is never read. recx assumes the reader that will look is another person's coding agent,
-and gives it something to read. `RECX.yaml` says what a repository does, which of its parts can
-be taken on their own, how to take them, and which checks anyone can rerun to see that they
-work.
+recx is meant to let coding agents find and evaluate reusable code from solo and small-team
+projects, which are otherwise difficult to discover among the volume of new repositories.
+`RECX.yaml` states, in a fixed machine-readable form, what a repository does, which of its parts
+can be taken on their own, how to take them, and which checks anyone can rerun to confirm that
+they work.
 
 It complements `AGENTS.md` rather than replacing it. `AGENTS.md` tells an agent how to work
 *inside* a repository. `RECX.yaml` tells an agent working somewhere else what it can take

{recx_cli-0.0.2 → recx_cli-0.0.4}/src/recx_cli/cli.py

@@ -1,4 +1,4 @@
-"""Command line: `recx check [PATH] [--no-repo]`."""
+"""Command line: `recx check`, `recx evidence`, `recx hook stop`."""
 
 from __future__ import annotations
 
@@ -8,6 +8,8 @@ from importlib import metadata
 from pathlib import Path
 
 from recx_cli.check import Unreadable, check_file, format_problem
+from recx_cli.evidence import HELP as EVIDENCE_HELP
+from recx_cli.evidence import evidence
 
 
 def _version() -> str:
@@ -45,6 +47,22 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="skip the checks that look at the repository (rule 3: module paths exist)",
     )
+    ev = sub.add_parser(
+        "evidence",
+        help="run a manifest's evidence commands (your own repository or a sandbox only)",
+        description=EVIDENCE_HELP,
+    )
+    ev.add_argument(
+        "path",
+        nargs="?",
+        default="RECX.yaml",
+        metavar="PATH",
+        help="a manifest file, or a directory holding RECX.yaml (default: ./RECX.yaml)",
+    )
+    ev.add_argument(
+        "--list", action="store_true", help="print each selected entry's commands without running anything"
+    )
+    ev.add_argument("--only", nargs="+", metavar="ID", help="run only the named evidence entries")
     hook = sub.add_parser(
         "hook",
         help="entry points for Claude Code hooks",
@@ -58,15 +76,24 @@ def build_parser() -> argparse.ArgumentParser:
         "RECX_STOP_HOOK=block (default) blocks the stop while RECX.yaml is invalid, "
         "warn only gives feedback, off does nothing.",
     )
+    hook_sub.add_parser(
+        "session-start",
+        help="SessionStart hook: record HEAD so the Stop hook can remind about manifest drift",
+        description="Read Claude Code's SessionStart hook JSON on stdin and record the "
+        "repository's HEAD for the session. Always exits 0 with no output. "
+        "RECX_DRIFT_REMINDER=off or RECX_STOP_HOOK=off does nothing.",
+    )
     return parser
 
 
 def main(argv: list[str] | None = None) -> int:
     args = build_parser().parse_args(argv)
     if args.command == "hook":
-        from recx_cli.hook import stop
+        from recx_cli.hook import session_start, stop
 
-        return stop()
+        return session_start() if args.hook_command == "session-start" else stop()
+    if args.command == "evidence":
+        return evidence(args.path, args.list, args.only)
     target = Path(args.path)
     if target.is_dir():
         target = target / "RECX.yaml"

recx_cli-0.0.4/src/recx_cli/drift.py

@@ -0,0 +1,178 @@
+"""Drift reminder: a manifest can be valid and stale.
+
+`recx hook session-start` records the repository's HEAD for the session.
+`recx hook stop` then asks which modules have changed files since, and, when
+RECX.yaml is not among them, reminds once per set of modules. The reminder is
+only ever feedback, never a block. Callers swallow every exception raised here.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+
+from recx_cli.check import parse
+
+MANIFEST = "RECX.yaml"
+SKILL = "recx:manifest"
+_HEAD = re.compile(r"[0-9a-fA-F]{7,64}")
+_SAFE_ID = re.compile(r"[A-Za-z0-9_-]{1,128}")
+
+
+def enabled() -> bool:
+    return os.environ.get("RECX_DRIFT_REMINDER", "").strip().lower() != "off"
+
+
+def state_dir() -> Path:
+    plugin_data = os.environ.get("CLAUDE_PLUGIN_DATA")
+    if plugin_data:
+        return Path(plugin_data)
+    base = os.environ.get("XDG_STATE_HOME") or str(Path.home() / ".local" / "state")
+    return Path(base) / "recx"
+
+
+def _state_file(session_id: str) -> Path | None:
+    if not isinstance(session_id, str) or not _SAFE_ID.fullmatch(session_id):
+        return None
+    return state_dir() / f"{session_id}.json"
+
+
+def read_state(session_id: str) -> dict:
+    """The session's state, or {} when absent, unreadable or corrupt."""
+    try:
+        path = _state_file(session_id)
+        if path is None:
+            return {}
+        data = json.loads(path.read_text(encoding="utf-8"))
+        if not isinstance(data, dict):
+            return {}
+        state: dict = {}
+        head = data.get("head")
+        if isinstance(head, str) and _HEAD.fullmatch(head):
+            state["head"] = head
+        reminded = data.get("reminded")
+        if isinstance(reminded, list):
+            state["reminded"] = [m for m in reminded if isinstance(m, str)]
+        return state
+    except Exception:  # noqa: BLE001 - a bad state file is ignored
+        return {}
+
+
+def write_state(session_id: str, state: dict) -> None:
+    path = _state_file(session_id)
+    if path is None:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(dir=path.parent, prefix=".tmp-", suffix=".json")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as fh:
+            json.dump(state, fh)
+        os.replace(tmp, path)
+    except BaseException:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+        raise
+
+
+def _git(top: Path, *args: str) -> str:
+    out = subprocess.run(
+        ["git", "-C", str(top), *args], capture_output=True, text=True, timeout=20, check=True
+    )
+    return out.stdout
+
+
+def head_of(top: Path) -> str | None:
+    value = _git(top, "rev-parse", "HEAD").strip()
+    return value if _HEAD.fullmatch(value) else None
+
+
+STATE_MAX_AGE_DAYS = 30
+
+
+def prune_state(max_age_days: int = STATE_MAX_AGE_DAYS) -> None:
+    """Delete session state files older than max_age_days; one is written per session."""
+    try:
+        cutoff = time.time() - max_age_days * 86400
+        for path in state_dir().glob("*.json"):
+            try:
+                if path.stat().st_mtime < cutoff:
+                    path.unlink()
+            except OSError:
+                continue
+    except OSError:
+        pass
+
+
+def session_start(session_id: str, top: Path) -> None:
+    """Record HEAD for the session. Skips when there is no manifest or the reminder is off."""
+    if not enabled() or not (top / MANIFEST).is_file():
+        return
+    prune_state()
+    head = head_of(top)
+    if head:
+        write_state(session_id, {"head": head, "reminded": []})
+
+
+def changed_files(top: Path, head: str | None) -> set[str]:
+    files: set[str] = set()
+    for base in [head, "HEAD"] if head else ["HEAD"]:
+        try:
+            files.update(_git(top, "diff", "--name-only", "-z", base, "--").split("\0"))
+            break
+        except (OSError, subprocess.SubprocessError):
+            continue
+    files.update(_git(top, "ls-files", "--others", "--exclude-standard", "-z").split("\0"))
+    files.discard("")
+    return files
+
+
+def affected_modules(manifest: Path, files: set[str]) -> list[str]:
+    data = parse(manifest.read_text(encoding="utf-8"))
+    modules = data.get("modules") if isinstance(data, dict) else None
+    found: list[str] = []
+    for mod in modules if isinstance(modules, list) else []:
+        if not isinstance(mod, dict):
+            continue
+        mid, path = mod.get("id"), mod.get("path")
+        if not isinstance(mid, str) or not isinstance(path, str):
+            continue
+        if path.endswith("/"):
+            hit = any(f.startswith(path) for f in files)
+        else:
+            hit = path in files
+        if hit and mid not in found:
+            found.append(mid)
+    return found
+
+
+def reminder(session_id: str | None, top: Path) -> str | None:
+    """The reminder text to emit now, or None. Records what it reminded about."""
+    if not enabled():
+        return None
+    state = read_state(session_id) if session_id else {}
+    files = changed_files(top, state.get("head"))
+    if MANIFEST in files:
+        return None
+    affected = affected_modules(top / MANIFEST, files)
+    already = set(state.get("reminded", []))
+    if not affected or set(affected) <= already:
+        return None
+    if session_id:
+        try:
+            write_state(session_id, {**state, "reminded": sorted(already | set(affected))})
+        except Exception:  # noqa: BLE001 - failing to record must not lose the reminder
+            pass
+    names = ", ".join(affected)
+    return (
+        f"Reminder, not an error: files under these {MANIFEST} modules changed this session "
+        f"while {MANIFEST} did not: {names}. Check whether the manifest still describes them, "
+        f"using the {SKILL} skill, and update it if it does not. If it is still accurate, "
+        f"nothing needs doing."
+    )

recx_cli-0.0.4/src/recx_cli/evidence.py

@@ -0,0 +1,77 @@
+"""`recx evidence`: run a manifest's own evidence commands, in the repository owner's CI."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from recx_cli.check import Unreadable, check_file, format_problem, parse
+
+HELP = (
+    "Run each evidence entry's setup and run commands (sh -c, from the manifest's directory, "
+    "with your environment) and report pass or fail. This runs the manifest's commands: use it "
+    "on your own repository or inside a sandbox, never on a stranger's manifest outside one "
+    "(SPEC, Trust). The manifest must pass `recx check` first. "
+    "Exit status: 0 all selected entries passed, 1 an entry failed or the manifest is invalid, "
+    "2 usage error or unreadable file."
+)
+
+
+def _run(command: str, cwd: Path) -> int:
+    sys.stdout.flush()
+    sys.stderr.flush()
+    return subprocess.run(["sh", "-c", command], cwd=cwd).returncode
+
+
+def evidence(path: str, list_only: bool = False, only: list[str] | None = None) -> int:
+    target = Path(path)
+    if target.is_dir():
+        target = target / "RECX.yaml"
+    label = str(target)
+    try:
+        problems = check_file(target, repo=True)
+    except Unreadable as exc:
+        print(f"{label}: cannot read: {exc}", file=sys.stderr)
+        return 2
+    if problems:
+        for p in problems:
+            print(format_problem(label, p))
+        return 1
+    entries = parse(target.read_text(encoding="utf-8")).get("evidence") or []
+    if only:
+        known = [e["id"] for e in entries]
+        unknown = [i for i in only if i not in known]
+        if unknown:
+            print(
+                f"recx evidence: no evidence entry with id {', '.join(unknown)} "
+                f"(known: {', '.join(known) or 'none'})",
+                file=sys.stderr,
+            )
+            return 2
+        entries = [e for e in entries if e["id"] in only]
+    if list_only:
+        for e in entries:
+            print(e["id"])
+            if "setup" in e:
+                print(f"  setup: {e['setup']}")
+            print(f"  run: {e['run']}")
+        return 0
+    cwd = target.resolve().parent
+    failed = False
+    for e in entries:
+        start = time.monotonic()
+        code = 0
+        for step in ("setup", "run"):
+            if step in e:
+                code = _run(e[step], cwd)
+                if code != 0:
+                    break
+        secs = f"{time.monotonic() - start:.1f}s"
+        if code == 0:
+            print(f"{e['id']}: pass ({secs})", flush=True)
+        else:
+            failed = True
+            print(f"{e['id']}: fail ({secs}, exit {code})", flush=True)
+    return 1 if failed else 0

{recx_cli-0.0.2 → recx_cli-0.0.4}/src/recx_cli/hook.py

@@ -13,6 +13,7 @@ import subprocess
 import sys
 from pathlib import Path
 
+from recx_cli import drift
 from recx_cli.check import Unreadable, check_file, format_problem
 
 MANIFEST = "RECX.yaml"
@@ -41,44 +42,89 @@ def _manifest_dir(cwd: str) -> Path:
     return start
 
 
-def _run() -> None:
-    if _mode() == "off":
-        return
+def _read_event() -> tuple[dict, Path] | None:
     raw = sys.stdin.read()
     if not raw.strip():
-        return
+        return None
     event = json.loads(raw)
     if not isinstance(event, dict):
-        return
+        return None
     cwd = event.get("cwd")
     if not isinstance(cwd, str) or not cwd:
-        return
-    manifest = _manifest_dir(cwd) / MANIFEST
+        return None
+    return event, _manifest_dir(cwd)
+
+
+def _validity(event: dict, top: Path) -> tuple[bool, str | None]:
+    """(manifest is valid, output to print). Knows nothing about drift."""
+    manifest = top / MANIFEST
     if not manifest.is_file():
-        return
+        return False, None
     try:
         problems = check_file(manifest, repo=True)
     except Unreadable:
-        return
+        return False, None
     if not problems:
-        return
+        return True, None
     lines = "\n".join(format_problem(MANIFEST, p) for p in problems)
     if _mode() == "block" and event.get("stop_hook_active") is not True:
         reason = (
             f"{MANIFEST} is invalid. Fix every problem below, using the {SKILL} skill, "
             f"then check it with `recx check` (or `uvx --from recx-cli recx check`):\n{lines}"
         )
-        print(json.dumps({"decision": "block", "reason": reason}))
-    else:
-        still = " still" if event.get("stop_hook_active") is True else ""
-        context = (
-            f"{MANIFEST} is{still} invalid. The {SKILL} skill explains how to fix it:\n{lines}"
-        )
-        print(
-            json.dumps(
-                {"hookSpecificOutput": {"hookEventName": "Stop", "additionalContext": context}}
-            )
-        )
+        return False, json.dumps({"decision": "block", "reason": reason})
+    still = " still" if event.get("stop_hook_active") is True else ""
+    context = f"{MANIFEST} is{still} invalid. The {SKILL} skill explains how to fix it:\n{lines}"
+    return False, json.dumps(
+        {"hookSpecificOutput": {"hookEventName": "Stop", "additionalContext": context}}
+    )
+
+
+def _drift(event: dict, top: Path) -> str | None:
+    try:
+        session = event.get("session_id")
+        text = drift.reminder(session if isinstance(session, str) else None, top)
+    except BaseException:  # noqa: BLE001 - the drift path must never block or raise
+        return None
+    if text is None:
+        return None
+    return json.dumps({"hookSpecificOutput": {"hookEventName": "Stop", "additionalContext": text}})
+
+
+def _run() -> None:
+    if _mode() == "off":
+        return
+    parsed = _read_event()
+    if parsed is None:
+        return
+    event, top = parsed
+    valid, output = _validity(event, top)
+    if output is not None:
+        print(output)
+    elif valid:
+        extra = _drift(event, top)
+        if extra is not None:
+            print(extra)
+
+
+def _session_start() -> None:
+    if _mode() == "off" or not drift.enabled():
+        return
+    parsed = _read_event()
+    if parsed is None:
+        return
+    event, top = parsed
+    session = event.get("session_id")
+    if isinstance(session, str):
+        drift.session_start(session, top)
+
+
+def session_start() -> int:
+    try:
+        _session_start()
+    except BaseException:  # noqa: BLE001 - a hook failure must not block the session
+        pass
+    return 0
 
 
 def stop() -> int:

{recx_cli-0.0.2 → recx_cli-0.0.4}/tests/test_check.py

@@ -238,8 +238,9 @@ def test_build_produces_sdist_and_wheel(tmp_path):
     out = tmp_path / "dist"
     env = {k: v for k, v in __import__("os").environ.items() if k != "VIRTUAL_ENV"}
     subprocess.run(["uv", "build", "--out-dir", str(out)], cwd=ROOT, check=True, capture_output=True, env=env)
-    wheels = list(out.glob("recx_cli-0.0.2-*.whl"))
-    sdists = list(out.glob("recx_cli-0.0.2.tar.gz"))
+    version = __import__("tomllib").loads((ROOT / "pyproject.toml").read_text())["project"]["version"]
+    wheels = list(out.glob(f"recx_cli-{version}-*.whl"))
+    sdists = list(out.glob(f"recx_cli-{version}.tar.gz"))
     assert len(wheels) == 1 and len(sdists) == 1
     with zipfile.ZipFile(wheels[0]) as z:
         names = z.namelist()