devready-cli 0.1.0__tar.gz → 0.2.0__tar.gz

{devready_cli-0.1.0 → devready_cli-0.2.0}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "devready",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "homepage": "https://devready-ten.vercel.app/",
   "description": "Read-only environment preflight: compares a project's declared Node/Python versions with what is installed.",
   "author": { "name": "DevReady contributors" },

{devready_cli-0.1.0 → devready_cli-0.2.0}/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.2.0 - 2026-10-16
+- `check --baseline FILE` (and `baseline:` Action input): show only results that changed since a saved JSON report.
+- Optional `.devready.json` (`skip`, `require`, `env`) and `devready init` (prints a starter).
+
 ## 0.1.0 - 2026-10-16
 - GitHub Action (`action.yml`) wrapping `devready check`.
 - `--format junit|sarif`, `--only`/`--skip` filters, and `devready fix --plan` (suggestions only).

{devready_cli-0.1.0 → devready_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: devready-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: A local-first, read-only CLI that checks a project's environment requirements against what is installed.
 Project-URL: Homepage, https://devready-ten.vercel.app/
 Project-URL: Repository, https://github.com/Evalogical-Inc/devReady
@@ -114,6 +114,9 @@ devready explain docker.daemon    # what a check means and how to fix it
 devready check --format junit     # or sarif, for CI
 devready check --only project --skip project.ports   # filter by id or prefix
 devready fix --plan               # suggested steps only; never runs them
+devready check --format json > baseline.json   # save a snapshot (commit it for a team baseline)
+devready check --baseline baseline.json          # show only what changed; fail only on new/worse failures
+devready init > .devready.json    # optional config: skip ids, require node/python, required env names
 devready mcp                      # run as an MCP server over stdio
 devready --version
 ```
@@ -202,7 +205,8 @@ See [SECURITY.md](SECURITY.md) to report a vulnerability.
 
 - [x] Docker CLI + daemon reachability, `.tool-versions`, `.env` key-name diff, disk space, git identity, `devready explain`
 - [x] Port-in-use checks, more ecosystems (Go, Rust, Java, Ruby, .NET, pnpm/yarn/bun), JUnit/SARIF output, `fix --plan`, GitHub Action
-- [ ] Config file, shared baseline (see [ROADMAP.md](ROADMAP.md))
+- [x] `.devready.json` config, `--baseline` snapshots
+- [ ] Platform-specific checks (see [ROADMAP.md](ROADMAP.md))
 - [ ] Standalone binaries
 
 Have a setup problem DevReady should catch? [Open an issue](https://github.com/Evalogical-Inc/devReady/issues/new/choose). Early feedback shapes the roadmap.

{devready_cli-0.1.0 → devready_cli-0.2.0}/README.md

@@ -90,6 +90,9 @@ devready explain docker.daemon    # what a check means and how to fix it
 devready check --format junit     # or sarif, for CI
 devready check --only project --skip project.ports   # filter by id or prefix
 devready fix --plan               # suggested steps only; never runs them
+devready check --format json > baseline.json   # save a snapshot (commit it for a team baseline)
+devready check --baseline baseline.json          # show only what changed; fail only on new/worse failures
+devready init > .devready.json    # optional config: skip ids, require node/python, required env names
 devready mcp                      # run as an MCP server over stdio
 devready --version
 ```
@@ -178,7 +181,8 @@ See [SECURITY.md](SECURITY.md) to report a vulnerability.
 
 - [x] Docker CLI + daemon reachability, `.tool-versions`, `.env` key-name diff, disk space, git identity, `devready explain`
 - [x] Port-in-use checks, more ecosystems (Go, Rust, Java, Ruby, .NET, pnpm/yarn/bun), JUnit/SARIF output, `fix --plan`, GitHub Action
-- [ ] Config file, shared baseline (see [ROADMAP.md](ROADMAP.md))
+- [x] `.devready.json` config, `--baseline` snapshots
+- [ ] Platform-specific checks (see [ROADMAP.md](ROADMAP.md))
 - [ ] Standalone binaries
 
 Have a setup problem DevReady should catch? [Open an issue](https://github.com/Evalogical-Inc/devReady/issues/new/choose). Early feedback shapes the roadmap.

{devready_cli-0.1.0 → devready_cli-0.2.0}/ROADMAP.md

@@ -2,12 +2,12 @@
 
 Principles (unchanged): read-only, local-first, zero runtime dependencies, Python >= 3.10, never print env values or raw command output.
 
-## Where we are (0.1.0)
+## Where we are (0.2.0)
 
 - Tools: Git, Node, npm, Python. Docker, Go, Ruby, Java, Rust, .NET, pnpm, Yarn, Bun only when the project declares them (details in the sections below).
 - Pins compared: `.nvmrc`, `.node-version`, `.python-version`, `package.json` engines.node, `pyproject.toml` requires-python, `.tool-versions` (node/python only).
 - Also: `.env.example` vs `.env` key names, git identity presence, free disk space.
-- Interfaces: `check` (text/JSON, exit 1 on `fail`), `explain`, `mcp`, Claude Code plugin, `AGENTS.md`.
+- Interfaces: `check` (text/JSON/JUnit/SARIF, `--only`/`--skip`/`--baseline`, exit 1 on `fail`), `fix --plan`, `init`, `explain`, `mcp`, GitHub Action, Claude Code plugin, `AGENTS.md`.
 - CI and PyPI publish workflows exist.
 
 ## Decisions (from the docs review)
@@ -41,14 +41,14 @@ Principles (unchanged): read-only, local-first, zero runtime dependencies, Pytho
 - [x] `devready fix --plan`: prints each `fail`/`warn` with its suggestion. Never runs anything. (Suggestions are prose today, not exact commands.)
 - [x] `--format sarif` and `junit` (SARIF has no file locations yet, so GitHub code scanning may not show alerts).
 - [x] `--only` / `--skip` filters by check id or dotted prefix (repeatable).
-- [ ] Optional `.devready.toml` to declare requirements and silence checks (needs a 3.10-safe parser, or limit to JSON).
-- [ ] `devready init` generates that file from what it detects.
+- [x] Optional `.devready.json` (JSON, so no parser dependency): `skip` ids, `require` node/python, required `env` names.
+- [x] `devready init` prints a starter file (does not write it; DevReady stays read-only).
 
-## 0.4 - Team and CI (in progress)
+## 0.4 - Team and CI
 
 - [x] GitHub Action (`action.yml`, composite). Untested on a real runner; needs a release with the new flags.
-- [ ] Shared baseline file (committed) to compare against.
-- [ ] `--watch`/diff mode: show only what changed since the last run.
+- [x] `--baseline FILE`: compare with a saved `--format json` report (commit it for a team baseline). Shows new/changed results; exit 1 only for a new or worse `fail`. Results that disappeared are not reported.
+- [x] Diff mode = `--baseline` against your own saved snapshot. DevReady never writes the snapshot (read-only), and there is no `--watch` loop.
 
 ## 0.5 - Platform specifics
 

{devready_cli-0.1.0 → devready_cli-0.2.0}/action.yml

@@ -16,6 +16,9 @@ inputs:
   skip:
     description: Space-separated check ids or prefixes to skip.
     default: ""
+  baseline:
+    description: Path to a committed `--format json` report; only changes are shown and only a new or worse failure fails the job.
+    default: ""
   version:
     description: devready-cli version to install (empty = latest).
     default: ""
@@ -36,10 +39,12 @@ runs:
         DR_ONLY: ${{ inputs.only }}
         DR_SKIP: ${{ inputs.skip }}
         DR_VERSION: ${{ inputs.version }}
+        DR_BASELINE: ${{ inputs.baseline }}
       run: |
         set -eu
         python -m pip install --quiet "devready-cli${DR_VERSION:+==$DR_VERSION}"
         args=(check --project "$DR_PROJECT" --format "$DR_FORMAT")
         for id in $DR_ONLY; do args+=(--only "$id"); done
         for id in $DR_SKIP; do args+=(--skip "$id"); done
+        if [ -n "$DR_BASELINE" ]; then args+=(--baseline "$DR_BASELINE"); fi
         python -m devready "${args[@]}"

{devready_cli-0.1.0 → devready_cli-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "devready-cli"
-version = "0.1.0"
+version = "0.2.0"
 description = "A local-first, read-only CLI that checks a project's environment requirements against what is installed."
 readme = "README.md"
 requires-python = ">=3.10"

devready_cli-0.2.0/src/devready/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

devready_cli-0.2.0/src/devready/baseline.py

@@ -0,0 +1,43 @@
+"""Compare a run with a saved report (`devready check --format json > baseline.json`).
+
+DevReady only reads the baseline; saving or committing it is up to you. That covers both a
+shared team baseline (committed file) and diffing against an earlier local run.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from devready.checks.project import _read
+from devready.models import Result, Status
+
+_ID = re.compile(r"^[a-z_]+(\.[a-z_]+)+$")
+_RANK = {Status.PASS: 0, Status.SKIP: 0, Status.WARN: 1, Status.ERROR: 2, Status.FAIL: 3}
+
+
+def load_baseline(path: Path) -> dict[str, Status] | None:
+    """check_id -> status, or None if the file is missing, too big, or not a v1 report."""
+    text = _read(path)
+    try:
+        data = json.loads(text) if text else None
+        if data["schema_version"] != 1:
+            return None
+        return {
+            r["check_id"]: Status(r["status"])
+            for r in data["results"]
+            if isinstance(r["check_id"], str) and _ID.match(r["check_id"])
+        }
+    except (ValueError, KeyError, TypeError):
+        return None
+
+
+def diff(results: list[Result], base: dict[str, Status]) -> tuple[list[Result], bool]:
+    """(results that are new or changed status, whether any FAIL got worse)."""
+    changed = [r for r in results if base.get(r.check_id) is not r.status]
+    worse = any(
+        r.status is Status.FAIL and _RANK[r.status] > _RANK.get(base.get(r.check_id), 0)
+        for r in changed
+    )
+    return changed, worse

devready_cli-0.2.0/src/devready/checks/config.py

@@ -0,0 +1,102 @@
+"""Optional `.devready.json`: extra requirements, required env var names, checks to skip.
+
+{"skip": ["project.ports"], "require": {"node": ">=20", "python": ">=3.11"}, "env": ["API_KEY"]}
+
+Read-only, same file rules as project.py. Env vars are tested for presence only; values are
+never read. Invalid files give one ERROR result and never echo file content.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from collections.abc import Mapping
+from pathlib import Path
+
+from devready.checks.project import _compare, _read
+from devready.models import Result, Status
+from devready.versions import SAFE_SPEC, parse_version
+
+CONFIG_FILE = ".devready.json"
+_ID = re.compile(r"^[a-z_]+(\.[a-z_]+)*$")
+_ENV_NAME = re.compile(r"^[A-Za-z_][A-Za-z0-9_]{0,63}$")
+_RUNTIMES = {"node": "Node", "python": "Python"}
+
+
+def _valid(cfg: object) -> bool:
+    if not isinstance(cfg, dict) or not set(cfg) <= {"skip", "require", "env"}:
+        return False
+    skip, req, env = cfg.get("skip", []), cfg.get("require", {}), cfg.get("env", [])
+    return (
+        isinstance(skip, list)
+        and all(isinstance(i, str) and _ID.match(i) for i in skip)
+        and isinstance(req, dict)
+        and all(
+            k in _RUNTIMES and isinstance(v, str) and SAFE_SPEC.match(v) for k, v in req.items()
+        )
+        and isinstance(env, list)
+        and all(isinstance(n, str) and _ENV_NAME.match(n) for n in env)
+    )
+
+
+def load_config(root: Path) -> tuple[dict | None, Result | None]:
+    """(config, None) if absent/valid ({} when absent), (None, error result) if invalid."""
+    text = _read(root / CONFIG_FILE)
+    if text is None:
+        return {}, None
+    try:
+        cfg = json.loads(text)
+    except ValueError:
+        cfg = None
+    if _valid(cfg):
+        return cfg, None
+    return None, Result(
+        "project.config.file",
+        "Config",
+        Status.ERROR,
+        f"{CONFIG_FILE} is invalid; it was ignored",
+        'Allowed keys: "skip" (check ids), "require" (node/python specs), "env" (variable names).',
+    )
+
+
+def check_config(
+    cfg: dict, node: str | None, python: str | None, environ: Mapping[str, str] = os.environ
+) -> list[Result]:
+    out: list[Result] = []
+    versions = {
+        "node": parse_version(node) if node else None,
+        "python": parse_version(python or ""),
+    }
+    for key, spec in cfg.get("require", {}).items():
+        out.append(
+            _compare(
+                f"project.{key}.config",
+                f"{_RUNTIMES[key]} required",
+                CONFIG_FILE,
+                spec,
+                versions[key],
+                Status.FAIL,
+            )
+        )
+    wanted = cfg.get("env", [])
+    if wanted:
+        missing = [n for n in wanted if n not in environ]
+        cid, title = "project.env.required", "Required env"
+        if missing:
+            out.append(
+                Result(
+                    cid,
+                    title,
+                    Status.FAIL,
+                    f"{len(missing)} of {len(wanted)} not set: {', '.join(missing[:10])}",
+                    "Set these variables in your shell or CI (values are never read).",
+                )
+            )
+        else:
+            out.append(Result(cid, title, Status.PASS, f"all {len(wanted)} variables are set"))
+    return out
+
+
+# Empty on purpose: pre-filling "env" from .env.example would make optional variables fail.
+TEMPLATE = json.dumps({"skip": [], "require": {}, "env": []}, indent=2)

{devready_cli-0.1.0 → devready_cli-0.2.0}/src/devready/cli.py

@@ -6,9 +6,10 @@ import sys
 from pathlib import Path
 
 from devready import __version__
+from devready.baseline import diff, load_baseline
 from devready.formats import fix_plan, junit, sarif
 from devready.models import Result, Status
-from devready.runner import report, run_checks
+from devready.runner import matches, report, run_checks
 
 EXIT_OK, EXIT_FAILED, EXIT_USAGE, EXIT_INTERNAL = 0, 1, 2, 3
 
@@ -20,12 +21,8 @@ def _text(results: list[Result]) -> str:
     return "\n".join(lines)
 
 
-def _matches(check_id: str, ids: list[str]) -> bool:
-    return any(check_id == i or check_id.startswith(i + ".") for i in ids)
-
-
 def _selected(check_id: str, only: list[str], skip: list[str]) -> bool:
-    return (not only or _matches(check_id, only)) and not _matches(check_id, skip)
+    return (not only or matches(check_id, only)) and not matches(check_id, skip)
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -34,10 +31,14 @@ def main(argv: list[str] | None = None) -> int:
     sub = parser.add_subparsers(dest="command", required=True)
     check = sub.add_parser("check", help="run read-only environment checks")
     check.add_argument("--format", choices=["text", "json", "junit", "sarif"], default="text")
+    check.add_argument(
+        "--baseline", metavar="FILE", help="saved --format json report; show only what changed"
+    )
     fix = sub.add_parser("fix", help="print suggested fixes (never runs them)")
     fix.add_argument("--plan", action="store_true", help="required: list steps without running")
     explain = sub.add_parser("explain", help="explain what a check id means")
     explain.add_argument("check_id")
+    sub.add_parser("init", help="print a starter .devready.json (does not write it)")
     sub.add_parser("mcp", help="run as an MCP server over stdio")
     for p in (check, fix):
         p.add_argument("--project", default=".", help="directory whose version pins to compare")
@@ -54,6 +55,12 @@ def main(argv: list[str] | None = None) -> int:
 
         return serve()
 
+    if args.command == "init":
+        from devready.checks.config import TEMPLATE
+
+        print(TEMPLATE)
+        return EXIT_OK
+
     if args.command == "explain":
         from devready.explain import EXPLANATIONS
 
@@ -86,12 +93,24 @@ def main(argv: list[str] | None = None) -> int:
     if args.command == "fix":
         print(fix_plan(results))
         return EXIT_OK
+
+    regressed = None
+    if args.baseline:
+        base = load_baseline(Path(args.baseline))
+        if base is None:
+            print("devready: baseline is not a readable devready JSON report", file=sys.stderr)
+            return EXIT_USAGE
+        total = len(results)
+        results, regressed = diff(results, base)
+        print(f"Compared with baseline: {len(results)} of {total} changed.", file=sys.stderr)
     if args.format == "json":
         print(json.dumps(report(results), indent=2))
     elif args.format in ("junit", "sarif"):
         print(junit(results) if args.format == "junit" else sarif(results))
     else:
         print(_text(results))
+    if regressed is not None:  # with a baseline only a new or worse FAIL breaks the build
+        return EXIT_FAILED if regressed else EXIT_OK
     return EXIT_FAILED if any(r.status is Status.FAIL for r in results) else EXIT_OK
 
 

{devready_cli-0.1.0 → devready_cli-0.2.0}/src/devready/explain.py

@@ -43,4 +43,8 @@ EXPLANATIONS = {
     "project.env.ignored": "Warns when .env exists but git would commit it (not ignored, or already tracked). Values are never shown.",
     "project.node.modules": "Checked when package.json lists dependencies: node_modules must exist and not be older than a lockfile.",
     "project.ports.free": "Ports declared in compose files (host side) or *PORT= lines in .env.example, tested by connecting to localhost. A busy port may be this project already running.",
+    "project.config.file": ".devready.json is optional. With unknown keys or invalid values it is ignored entirely. Run `devready init` for a starter.",
+    "project.node.config": "require.node in .devready.json is a hard requirement (fails when unmet).",
+    "project.python.config": "require.python in .devready.json is a hard requirement (fails when unmet).",
+    "project.env.required": "Variable NAMES listed under env in .devready.json must be set in the environment. Values are never read.",
 }

{devready_cli-0.1.0 → devready_cli-0.2.0}/src/devready/runner.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import platform
 from pathlib import Path
 
+from devready.checks.config import check_config, load_config
 from devready.checks.extras import check_disk, check_docker, check_git_identity
 from devready.checks.health import check_health
 from devready.checks.project import check_project
@@ -12,7 +13,12 @@ from devready.checks.tools import TOOLS, check_tool
 from devready.models import Result
 
 
+def matches(check_id: str, ids: list[str]) -> bool:
+    return any(check_id == i or check_id.startswith(i + ".") for i in ids)
+
+
 def run_checks(root: Path) -> list[Result]:
+    cfg, cfg_error = load_config(root)
     results = [check_python()]
     versions = {}
     for tool in TOOLS:
@@ -21,7 +27,12 @@ def run_checks(root: Path) -> list[Result]:
     results += check_git_identity()
     results += check_project(root, versions["node"], platform.python_version())
     results += check_runtimes(root) + check_health(root)
-    return results + check_docker(root) + check_disk(root)
+    results += check_docker(root) + check_disk(root)
+    results += (
+        [cfg_error] if cfg_error else check_config(cfg, versions["node"], platform.python_version())
+    )
+    skip = (cfg or {}).get("skip", [])
+    return [r for r in results if not matches(r.check_id, skip)]
 
 
 def report(results: list[Result]) -> dict:

devready_cli-0.2.0/tests/unit/test_baseline.py

@@ -0,0 +1,49 @@
+import json
+
+from devready.baseline import diff, load_baseline
+from devready.cli import main
+from devready.models import Result, Status
+from devready.runner import report
+
+
+def res(cid, status):
+    return Result(cid, cid, status, "s")
+
+
+def save(path, results):
+    path.write_text(json.dumps(report(results)))
+    return path
+
+
+def test_load_rejects_bad_files(tmp_path):
+    assert load_baseline(tmp_path / "missing.json") is None
+    for bad in ("{nope", "[]", '{"schema_version": 2, "results": []}', '{"schema_version": 1}'):
+        (tmp_path / "b.json").write_text(bad)
+        assert load_baseline(tmp_path / "b.json") is None
+    (tmp_path / "b.json").write_text(
+        json.dumps({"schema_version": 1, "results": [{"check_id": "Bad Id", "status": "pass"}]})
+    )
+    assert load_baseline(tmp_path / "b.json") == {}  # invalid ids are dropped, not echoed
+
+
+def test_diff_changed_new_and_worse():
+    base = {"a.x": Status.PASS, "b.x": Status.FAIL, "c.x": Status.WARN}
+    now = [
+        res("a.x", Status.PASS),  # unchanged
+        res("b.x", Status.FAIL),  # unchanged failure: not a regression
+        res("c.x", Status.FAIL),  # worse
+        res("d.x", Status.WARN),  # new, not a fail
+    ]
+    changed, worse = diff(now, base)
+    assert [r.check_id for r in changed] == ["c.x", "d.x"] and worse
+    assert diff(now[:2], base) == ([], False)
+    assert diff([res("e.x", Status.FAIL)], base)[1]  # new FAIL counts
+
+
+def test_cli_baseline_exit_codes(tmp_path, capsys):
+    base = save(tmp_path / "base.json", [res("python.version", Status.PASS)])
+    assert main(["check", "--only", "python", "--baseline", str(base), "--format", "json"]) == 0
+    assert json.loads(capsys.readouterr().out)["results"] == []  # nothing changed
+    broken = save(tmp_path / "old.json", [res("python.version", Status.FAIL)])
+    assert main(["check", "--only", "python", "--baseline", str(broken)]) == 0
+    assert main(["check", "--baseline", str(tmp_path / "missing.json")]) == 2

devready_cli-0.2.0/tests/unit/test_config.py

@@ -0,0 +1,67 @@
+import json
+
+from devready.checks.config import check_config, load_config
+from devready.cli import main
+from devready.explain import EXPLANATIONS
+from devready.models import Status
+from devready.runner import run_checks
+
+
+def write(tmp_path, cfg):
+    (tmp_path / ".devready.json").write_text(cfg if isinstance(cfg, str) else json.dumps(cfg))
+
+
+def test_absent_and_valid(tmp_path):
+    assert load_config(tmp_path) == ({}, None)
+    write(tmp_path, {"skip": ["project.ports"], "require": {"node": ">=20"}, "env": ["API_KEY"]})
+    cfg, err = load_config(tmp_path)
+    assert err is None and cfg["skip"] == ["project.ports"]
+
+
+def test_invalid_is_one_error_and_never_echoed(tmp_path):
+    for bad in (
+        "{nope",
+        "[]",
+        {"unknown": 1},
+        {"skip": "project"},
+        {"skip": ["Bad Id; rm -rf"]},
+        {"require": {"ruby": ">=3"}},
+        {"require": {"node": "PWNED-MARKER; curl x"}},
+        {"env": ["bad name"]},
+    ):
+        write(tmp_path, bad)
+        cfg, err = load_config(tmp_path)
+        assert cfg is None and err.status is Status.ERROR
+        assert "PWNED" not in str(err) and "rm -rf" not in str(err)
+
+
+def test_require_and_env(tmp_path):
+    cfg = {"require": {"node": ">=20", "python": ">=3.99"}, "env": ["A_SET", "B_MISSING"]}
+    r = {x.check_id: x for x in check_config(cfg, "18.0.0", "3.12.0", {"A_SET": "hunter2"})}
+    assert r["project.node.config"].status is Status.FAIL
+    assert r["project.python.config"].status is Status.FAIL
+    assert r["project.env.required"].status is Status.FAIL
+    assert "B_MISSING" in r["project.env.required"].summary
+    assert "hunter2" not in str(r)
+    ok = check_config({"env": ["A"]}, None, "3.12.0", {"A": "x"})
+    assert ok[0].status is Status.PASS
+
+
+def test_run_checks_applies_skip_and_requirements(tmp_path):
+    write(tmp_path, {"skip": ["git", "disk"], "require": {"python": ">=99"}})
+    ids = {r.check_id: r for r in run_checks(tmp_path)}
+    assert "git.version" not in ids and "disk.space" not in ids and "git.identity" not in ids
+    assert ids["project.python.config"].status is Status.FAIL
+
+
+def test_init_prints_valid_config_and_writes_nothing(tmp_path, capsys, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    assert main(["init"]) == 0
+    write(tmp_path, capsys.readouterr().out)  # the test writes it, init does not
+    assert load_config(tmp_path)[1] is None
+
+
+def test_ids_have_explanations():
+    for cid in ("project.config.file", "project.node.config", "project.python.config",
+                "project.env.required"):  # fmt: skip
+        assert cid in EXPLANATIONS

devready_cli-0.1.0/src/devready/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.0"