devready-cli 0.0.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

devready/__init__.py

@@ -1 +1 @@
-__version__ = "0.0.4"
+__version__ = "0.2.0"

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/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/checks/health.py

@@ -0,0 +1,116 @@
+"""Project health: .env ignored by git, node_modules vs lockfile, ports the project declares.
+
+Read-only. Only numbers and fixed phrases reach the report, never file content.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import shutil
+import socket
+from collections.abc import Callable
+from pathlib import Path
+
+from devready.checks.extras import DOCKER_FILES, _run
+from devready.checks.project import _read
+from devready.models import Result, Status
+
+LOCKFILES = ("package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock")
+_COMPOSE_PORT = re.compile(r"^\s*-\s*[\"']?(?:[\d.]+:)?(\d{2,5}):\d+", re.M)
+_ENV_PORT = re.compile(r"^\s*(?:export\s+)?[A-Z_]*PORT\s*=\s*[\"']?(\d{2,5})\b", re.M)
+MAX_PORTS = 20
+
+
+def _listening(port: int) -> bool:
+    with socket.socket() as s:
+        s.settimeout(0.3)
+        return s.connect_ex(("127.0.0.1", port)) == 0
+
+
+def check_env_ignored(root: Path, run: Callable = _run) -> list[Result]:
+    """A .env that git would commit is a leak risk. Silent outside a git repo."""
+    git = shutil.which("git")
+    if not (root / ".env").is_file() or not git:
+        return []
+    p = run([git, "-C", str(root), "check-ignore", "-q", ".env"])
+    if p is None or p.returncode not in (0, 1):
+        return []
+    if p.returncode == 0:
+        return [Result("project.env.ignored", "Env ignored", Status.PASS, ".env is git-ignored")]
+    return [
+        Result(
+            "project.env.ignored",
+            "Env ignored",
+            Status.WARN,
+            ".env is not ignored by git (or is already tracked)",
+            "Add .env to .gitignore; if it is tracked, untrack it and rotate its secrets.",
+        )
+    ]
+
+
+def check_node_modules(root: Path) -> list[Result]:
+    text = _read(root / "package.json")
+    try:
+        data = json.loads(text) if text else None
+    except ValueError:
+        return []  # project.py already reports the parse error
+    if not isinstance(data, dict) or not any(
+        isinstance(data.get(k), dict) and data[k] for k in ("dependencies", "devDependencies")
+    ):
+        return []
+    cid, title = "project.node.modules", "node_modules"
+    nm = root / "node_modules"
+    if not nm.is_dir():
+        return [
+            Result(
+                cid,
+                title,
+                Status.WARN,
+                "node_modules not found",
+                "Install dependencies with your package manager (npm, pnpm, yarn or bun).",
+            )
+        ]
+    # ponytail: directory mtime, not a content comparison; upgrade if it proves noisy.
+    locks = [root / f for f in LOCKFILES if (root / f).is_file()]
+    if any(lock.stat().st_mtime > nm.stat().st_mtime for lock in locks):
+        return [
+            Result(
+                cid,
+                title,
+                Status.WARN,
+                "a lockfile is newer than node_modules",
+                "Re-run your package manager's install to sync dependencies.",
+            )
+        ]
+    return [Result(cid, title, Status.PASS, "node_modules is present and not older than lockfiles")]
+
+
+def check_ports(root: Path, in_use: Callable[[int], bool] = _listening) -> list[Result]:
+    ports: set[int] = set()
+    for name in DOCKER_FILES[1:]:  # compose files only
+        if (text := _read(root / name)) is not None:
+            ports.update(int(p) for p in _COMPOSE_PORT.findall(text))
+    if (text := _read(root / ".env.example")) is not None:
+        ports.update(int(p) for p in _ENV_PORT.findall(text))
+    ports = {p for p in ports if 0 < p < 65536}
+    if not ports:
+        return []
+    cid, title = "project.ports.free", "Ports"
+    shown = sorted(ports)[:MAX_PORTS]
+    busy = [p for p in shown if in_use(p)]
+    if busy:
+        return [
+            Result(
+                cid,
+                title,
+                Status.WARN,
+                f"already in use on localhost: {', '.join(map(str, busy))}",
+                "Stop the other process or change the port; it may be this project running.",
+            )
+        ]
+    return [Result(cid, title, Status.PASS, f"{len(shown)} declared port(s) are free")]
+
+
+def check_health(root: Path) -> list[Result]:
+    return check_env_ignored(root) + check_node_modules(root) + check_ports(root)

devready/checks/runtimes.py

@@ -0,0 +1,103 @@
+"""Go, Ruby, Java, Rust, .NET, pnpm, Yarn, Bun: checked only when the project pins them.
+
+Same read-only rules as project.py. Only digits/validated specs ever reach the report.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from collections.abc import Callable
+from pathlib import Path
+
+from devready.checks.project import _compare, _read
+from devready.checks.tools import check_tool
+from devready.models import Result, Status
+from devready.versions import parse_version
+
+
+def _first_version(text: str) -> str | None:
+    m = re.search(r"\d+(?:\.\d+){0,2}", text.strip().split("\n", 1)[0])
+    return m.group() if m else None
+
+
+def _go_mod(text: str) -> str | None:
+    m = re.search(r"^go\s+(\d+(?:\.\d+){1,2})", text, re.M)
+    return f">={m.group(1)}" if m else None
+
+
+def _rust(text: str) -> str | None:
+    m = re.search(r"^\s*channel\s*=\s*[\"']([^\"']*)[\"']", text, re.M)
+    return m.group(1) if m else text.strip().split("\n", 1)[0] or None
+
+
+def _global_json(text: str) -> str | None:
+    try:
+        spec = json.loads(text).get("sdk", {}).get("version")
+    except (ValueError, AttributeError):
+        return None
+    return spec if isinstance(spec, str) else None
+
+
+def _pkg_manager(name: str) -> Callable[[str], str | None]:
+    def extract(text: str) -> str | None:
+        try:
+            value = json.loads(text).get("packageManager")
+        except (ValueError, AttributeError):
+            return None
+        m = (
+            re.fullmatch(rf"{name}@(\d+(?:\.\d+){{0,2}})(?:\+.*)?", value)
+            if isinstance(value, str)
+            else None
+        )
+        return m.group(1) if m else None
+
+    return extract
+
+
+# key -> (title, exe, version args, docs, .tool-versions name, [(id, file, extractor, miss)])
+RUNTIMES: dict[str, tuple] = {
+    "go": ("Go", "go", ("version",), "https://go.dev/doc/install", "golang",
+           [("project.go.mod", "go.mod", _go_mod, Status.FAIL)]),
+    "ruby": ("Ruby", "ruby", ("--version",), "https://www.ruby-lang.org/en/downloads/", "ruby",
+             [("project.ruby.pin", ".ruby-version", _first_version, Status.WARN)]),
+    "java": ("Java", "java", ("-version",), "https://adoptium.net/", "java",
+             [("project.java.pin", ".java-version", _first_version, Status.WARN)]),
+    "rust": ("Rust", "rustc", ("--version",), "https://rustup.rs/", "rust",
+             [("project.rust.toolchain", "rust-toolchain.toml", _rust, Status.WARN),
+              ("project.rust.toolchain", "rust-toolchain", _rust, Status.WARN)]),
+    "dotnet": ("dotnet", "dotnet", ("--version",), "https://dotnet.microsoft.com/download",
+               "dotnet", [("project.dotnet.global", "global.json", _global_json, Status.WARN)]),
+    # packageManager in package.json pins one manager, e.g. "pnpm@9.1.0"
+    "pnpm": ("pnpm", "pnpm", ("--version",), "https://pnpm.io/installation", "pnpm",
+             [("project.pnpm.pin", "package.json", _pkg_manager("pnpm"), Status.WARN)]),
+    "yarn": ("Yarn", "yarn", ("--version",), "https://yarnpkg.com/getting-started/install", "yarn",
+             [("project.yarn.pin", "package.json", _pkg_manager("yarn"), Status.WARN)]),
+    "bun": ("Bun", "bun", ("--version",), "https://bun.sh/docs/installation", "bun",
+            [("project.bun.pin", "package.json", _pkg_manager("bun"), Status.WARN)]),
+}  # fmt: skip
+
+
+def check_runtimes(
+    root: Path, tool: Callable = check_tool, runtimes: dict[str, tuple] = RUNTIMES
+) -> list[Result]:
+    tv = _read(root / ".tool-versions") or ""
+    tv_pins = {p[0]: p[1] for line in tv.splitlines() if len(p := line.split("#")[0].split()) >= 2}
+    out: list[Result] = []
+    for key, (title, exe, args, docs, tv_name, pins) in runtimes.items():
+        found: list[tuple[str, str, str, Status]] = []
+        for cid, fname, extract, miss in pins:
+            text = _read(root / fname)
+            if text is not None and (spec := extract(text)):
+                found.append((cid, fname, spec, miss))
+                break
+        if tv_name in tv_pins:
+            found.append((f"project.{key}.tool_versions", ".tool-versions", tv_pins[tv_name],
+                          Status.WARN))  # fmt: skip
+        if not found:
+            continue
+        res, ver = tool(f"{key}.version", title, exe, docs, args)
+        out.append(res)
+        v = parse_version(ver) if ver else None
+        out += [_compare(c, f"{title} pin", src, spec, v, miss) for c, src, spec, miss in found]
+    return out

devready/checks/tools.py

@@ -19,7 +19,9 @@ TOOLS = [
 ]
 
 
-def check_tool(check_id: str, title: str, exe: str, docs: str) -> tuple[Result, str | None]:
+def check_tool(
+    check_id: str, title: str, exe: str, docs: str, args: tuple[str, ...] = ("--version",)
+) -> tuple[Result, str | None]:
     """Returns (result, parsed version or None). Raw command output is never reported."""
     path = shutil.which(exe)
     if not path:
@@ -33,11 +35,12 @@ def check_tool(check_id: str, title: str, exe: str, docs: str) -> tuple[Result,
         ), None
     try:
         proc = subprocess.run(
-            [path, "--version"], capture_output=True, text=True, timeout=5, errors="replace"
+            [path, *args], capture_output=True, text=True, timeout=5, errors="replace"
         )
     except (subprocess.TimeoutExpired, OSError):
         return Result(check_id, title, Status.ERROR, "Could not run version command"), None
-    m = re.search(r"\d+(?:\.\d+)+", proc.stdout[:200]) if proc.returncode == 0 else None
+    out = (proc.stdout or proc.stderr)[:200]  # java -version prints to stderr
+    m = re.search(r"\d+(?:\.\d+)+", out) if proc.returncode == 0 else None
     if not m:
         return Result(check_id, title, Status.ERROR, "Version output not recognized"), None
     return Result(check_id, title, Status.PASS, f"{m.group()} found"), m.group()

devready/cli.py

@@ -6,8 +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
 
@@ -19,16 +21,29 @@ def _text(results: list[Result]) -> str:
     return "\n".join(lines)
 
 
+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)
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(prog="devready", description=__doc__)
     parser.add_argument("--version", action="version", version=f"devready {__version__}")
     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"], default="text")
+    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")
-    check.add_argument("--project", default=".", help="directory whose version pins to compare")
+    for p in (check, fix):
+        p.add_argument("--project", default=".", help="directory whose version pins to compare")
+        p.add_argument("--only", action="append", default=[], metavar="ID", help="check id/prefix")
+        p.add_argument("--skip", action="append", default=[], metavar="ID", help="check id/prefix")
 
     try:
         args = parser.parse_args(argv)
@@ -40,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
 
@@ -50,6 +71,13 @@ def main(argv: list[str] | None = None) -> int:
         print(text)
         return EXIT_OK
 
+    if args.command == "fix" and not args.plan:
+        print(
+            "devready: fix only supports --plan (DevReady never changes your system)",
+            file=sys.stderr,
+        )
+        return EXIT_USAGE
+
     root = Path(args.project)
     if not root.is_dir():
         print(f"devready: not a directory: {args.project}", file=sys.stderr)
@@ -60,10 +88,29 @@ def main(argv: list[str] | None = None) -> int:
         print(f"devready: internal error ({type(e).__name__})", file=sys.stderr)
         return EXIT_INTERNAL
 
+    results = [r for r in results if _selected(r.check_id, args.only, args.skip)]
+
+    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/explain.py

@@ -16,4 +16,35 @@ EXPLANATIONS = {
     "docker.daemon": "The Docker CLI can exist while the daemon is stopped. Start Docker Desktop or the service.",
     "git.identity": "Commits need user.name and user.email. DevReady checks they exist, never what they are.",
     "disk.space": "Warns below 1 GB free where the project lives; installs and builds can fail when the disk is full.",
+    "go.version": "Go toolchain; checked only when the project has a go.mod or a golang line in .tool-versions.",
+    "ruby.version": "Ruby interpreter; checked only when the project pins it (.ruby-version or .tool-versions).",
+    "java.version": "Java runtime; checked only when the project pins it (.java-version or .tool-versions).",
+    "rust.version": "Rust compiler (rustc); checked only when the project has a rust-toolchain file or pin.",
+    "dotnet.version": "The .NET SDK; checked only when the project has a global.json or a dotnet pin.",
+    "project.go.mod": "The go directive in go.mod is the minimum Go version. A lower toolchain fails the check.",
+    "project.go.tool_versions": ".tool-versions (asdf/mise) pins Go for this project.",
+    "project.ruby.pin": ".ruby-version pins Ruby for this project (rbenv, rvm, mise).",
+    "project.ruby.tool_versions": ".tool-versions (asdf/mise) pins Ruby for this project.",
+    "project.java.pin": ".java-version pins Java for this project (jenv, mise).",
+    "project.java.tool_versions": ".tool-versions (asdf/mise) pins Java for this project.",
+    "project.rust.toolchain": "rust-toolchain(.toml) pins the Rust channel. Named channels such as stable are reported as not evaluated.",
+    "project.rust.tool_versions": ".tool-versions (asdf/mise) pins Rust for this project.",
+    "project.dotnet.global": "global.json sdk.version pins the .NET SDK for this project.",
+    "project.dotnet.tool_versions": ".tool-versions (asdf/mise) pins .NET for this project.",
+    "pnpm.version": "pnpm package manager; checked only when package.json packageManager names pnpm.",
+    "yarn.version": "Yarn package manager; checked only when package.json packageManager names yarn.",
+    "bun.version": "Bun runtime and package manager; checked only when package.json packageManager names bun.",
+    "project.pnpm.pin": "package.json packageManager pins the pnpm version (corepack enable can install it).",
+    "project.yarn.pin": "package.json packageManager pins the Yarn version (corepack enable can install it).",
+    "project.bun.pin": "package.json packageManager pins the Bun version.",
+    "project.pnpm.tool_versions": ".tool-versions (asdf/mise) pins pnpm for this project.",
+    "project.yarn.tool_versions": ".tool-versions (asdf/mise) pins Yarn for this project.",
+    "project.bun.tool_versions": ".tool-versions (asdf/mise) pins Bun for this project.",
+    "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/formats.py

@@ -0,0 +1,82 @@
+"""Extra output formats for CI: JUnit XML, SARIF 2.1.0, and the read-only fix plan."""
+
+from __future__ import annotations
+
+import json
+import xml.etree.ElementTree as ET
+
+from devready import __version__
+from devready.models import Result, Status
+
+_LEVEL = {Status.FAIL: "error", Status.ERROR: "error", Status.WARN: "warning"}
+
+
+def junit(results: list[Result]) -> str:
+    count = lambda *s: str(sum(r.status in s for r in results))  # noqa: E731
+    suite = ET.Element(
+        "testsuite",
+        name="devready",
+        tests=str(len(results)),
+        failures=count(Status.FAIL),
+        errors=count(Status.ERROR),
+        skipped=count(Status.SKIP),
+    )
+    for r in results:
+        case = ET.SubElement(suite, "testcase", classname="devready", name=r.check_id)
+        if r.status is Status.FAIL:
+            ET.SubElement(case, "failure", message=r.summary)
+        elif r.status is Status.ERROR:
+            ET.SubElement(case, "error", message=r.summary)
+        elif r.status is Status.SKIP:
+            ET.SubElement(case, "skipped", message=r.summary)
+        elif r.status is Status.WARN:  # warnings do not fail the suite; keep them visible
+            ET.SubElement(case, "system-out").text = f"WARN: {r.summary}"
+    return ET.tostring(suite, encoding="unicode", xml_declaration=False)
+
+
+def sarif(results: list[Result]) -> str:
+    # ponytail: findings carry no file location, so GitHub code scanning may not display them;
+    # add locations once checks know which file they read.
+    bad = [r for r in results if r.status in _LEVEL]
+    doc = {
+        "$schema": "https://json.schemastore.org/sarif-2.1.0.json",
+        "version": "2.1.0",
+        "runs": [
+            {
+                "tool": {
+                    "driver": {
+                        "name": "devready",
+                        "version": __version__,
+                        "rules": [
+                            {"id": i, "shortDescription": {"text": i}}
+                            for i in sorted({r.check_id for r in bad})
+                        ],
+                    }
+                },
+                "results": [
+                    {
+                        "ruleId": r.check_id,
+                        "level": _LEVEL[r.status],
+                        "message": {"text": f"{r.summary}. {r.suggestion}".strip()},
+                    }
+                    for r in bad
+                ],
+            }
+        ],
+    }
+    return json.dumps(doc, indent=2)
+
+
+def fix_plan(results: list[Result]) -> str:
+    """Suggested next steps only. DevReady never runs any of them."""
+    todo = [r for r in results if r.status in (Status.FAIL, Status.WARN) and r.suggestion]
+    lines = ["DevReady - Fix Plan (suggestions only)", ""]
+    if not todo:
+        lines.append("Nothing to fix.")
+    for i, r in enumerate(todo, 1):
+        lines.append(f"{i}. [{r.status.value.upper()}] {r.title}: {r.summary}")
+        lines.append(f"   -> {r.suggestion}")
+        if r.docs_url:
+            lines.append(f"   {r.docs_url}")
+    lines += ["", "DevReady did not run any of these. Nothing was changed."]
+    return "\n".join(lines)

devready/runner.py

@@ -3,14 +3,22 @@ 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
 from devready.checks.python_check import check_python
+from devready.checks.runtimes import check_runtimes
 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:
@@ -18,7 +26,13 @@ def run_checks(root: Path) -> list[Result]:
         results.append(result)
     results += check_git_identity()
     results += check_project(root, versions["node"], platform.python_version())
-    return results + check_docker(root) + check_disk(root)
+    results += check_runtimes(root) + check_health(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.0.4.dist-info → devready_cli-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: devready-cli
-Version: 0.0.4
+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
@@ -111,6 +111,12 @@ devready check                    # human-readable report for the current direct
 devready check --project ../app   # inspect another project's pins
 devready check --format json      # machine-readable (see docs/schema.json)
 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
 ```
@@ -148,6 +154,16 @@ devready --version
 }
 ```
 
+## Use it in CI (GitHub Actions)
+
+```yaml
+- uses: Evalogical-Inc/devReady@main   # pin a release tag once published
+  with:
+    skip: project.ports                  # optional; also: only, format, project, version
+```
+
+The job fails when a declared requirement is unmet (`fail`). It installs `devready-cli` from PyPI, so flags added after your installed release (`--only`, `--skip`, junit/sarif) need a release that includes them; set `version:` to pin one.
+
 ## Use it with AI coding agents
 
 DevReady ships the same engine three ways, so your agent can verify the environment *before* it installs, builds or tests.
@@ -181,15 +197,16 @@ See [SECURITY.md](SECURITY.md) to report a vulnerability.
 
 ## Limitations (alpha)
 
-- Checks today: Python, Git (+ identity set), Node.js, npm, project pins (`.nvmrc`, `.node-version`, `.python-version`, `.tool-versions`, `package.json` engines, `pyproject.toml` requires-python), `.env.example` vs `.env` key names, Docker CLI + daemon (only when the project has a Dockerfile/compose file), and free disk space.
+- Checks today: Python, Git (+ identity set), Node.js, npm, project pins (`.nvmrc`, `.node-version`, `.python-version`, `.tool-versions`, `package.json` engines, `pyproject.toml` requires-python), `.env.example` vs `.env` key names, Docker CLI + daemon (only when the project has a Dockerfile/compose file), free disk space, and (only when the project declares them) Go, Ruby, Java, Rust, .NET, pnpm, Yarn and Bun pins, `.env` not git-ignored, `node_modules` vs lockfile, and declared ports already in use.
 - The version-range matcher covers common npm/PEP 440 syntax; pre-releases and exotic ranges report `skip` rather than guess.
 - The Python version compared is the interpreter running DevReady, not necessarily your project's virtualenv.
 
 ## Roadmap
 
 - [x] Docker CLI + daemon reachability, `.tool-versions`, `.env` key-name diff, disk space, git identity, `devready explain`
-- [ ] Port-in-use checks (ports read from compose files)
-- [ ] More ecosystems (Go, Rust, Java, Ruby pins)
+- [x] Port-in-use checks, more ecosystems (Go, Rust, Java, Ruby, .NET, pnpm/yarn/bun), JUnit/SARIF output, `fix --plan`, GitHub Action
+- [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.
@@ -202,6 +219,10 @@ PRs welcome, especially new read-only checks and platform fixes. Start with [CON
 ruff check . && pytest
 ```
 
+## About Evalogical
+
+DevReady is built and maintained by [Evalogical](https://evalogical.com/), a software company offering AI-enabled product engineering, custom software and IT services. Need help with a product or an engineering team? [Talk to us](https://evalogical.com/contactus).
+
 ## License
 
 [MIT](LICENSE) © Evalogical Inc

devready_cli-0.2.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+devready/__init__.py,sha256=Zn1KFblwuFHiDRdRAiRnDBRkbPttWh44jKa5zG2ov0E,22
+devready/__main__.py,sha256=c-4qpm2SKZs1nENGzSnPnChNTo8iMwjY0XaPyAApn4I,60
+devready/baseline.py,sha256=pfVzZ695bLEiSWKUBK0PNDp1S2UWTWj9lfUCDAsVS4g,1524
+devready/cli.py,sha256=RPijit2MT_ouZgD2TOUu1x-6YJevRIkh_a1wTWbMeuY,4619
+devready/explain.py,sha256=nYzzwtZGpn-FQQR8_KxC61_FLf7jCuQEv4iX-Fvqqr0,5140
+devready/formats.py,sha256=akN62ouKLeZQB6POcXNzINYKHwpUd4im0n2-9rtB8eE,3129
+devready/mcp_server.py,sha256=zVm89kZL_-pZwTSWkt6rxKonytNklUSa0RCQkX0lzFk,3177
+devready/models.py,sha256=KyGp3ie2LVQmuSfzLV8tbEH_hJyU5-Vi11d0JcQPAuE,646
+devready/runner.py,sha256=MVQh-dlsXnihWSbvbF4XKuFxgIyoywtL-9I-y0XrPpc,1456
+devready/versions.py,sha256=dXKIl1-qvcfadRNaCURMoftwx7YtadDZ-YfUp-85XZc,2112
+devready/checks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devready/checks/config.py,sha256=SGyIot_QXmZtPLIybtxnyJEFL2aV1NemSqX_fXbFI6A,3471
+devready/checks/extras.py,sha256=pDJbFaAwjkLc92tcFagOmj-5c_vMx32_MtYa_DBfCz8,3428
+devready/checks/health.py,sha256=woaaUL2TJ_biRuiStXqJtnvPua_y69bW2quNPlwd7tQ,4235
+devready/checks/project.py,sha256=UnnjuZmG2aXXBAY45wTEP-bj4CWODMv3DPfEi1V_QDE,5983
+devready/checks/python_check.py,sha256=uQCd-N0LEwt9R5gwZm5mlYiPMST1JXVDNQOdZ5xpako,328
+devready/checks/runtimes.py,sha256=OiC5LEhmfkiMseP2PbQS6Dc6TC2JhYNICU6LmdFFvqk,4446
+devready/checks/tools.py,sha256=AiL9TdIREmY7tEkkpt62DELKuJ2lhu3XcA2yGak9QkA,1616
+devready_cli-0.2.0.dist-info/METADATA,sha256=b76wbK0qZnoG8aNy66wxg8QmFDPENvL3GhzAwa2-RMQ,10533
+devready_cli-0.2.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+devready_cli-0.2.0.dist-info/entry_points.txt,sha256=7oAecSWtsIt7qLOP8PipOeDqhXCkEJat0oxhD4T1RpY,47
+devready_cli-0.2.0.dist-info/licenses/LICENSE,sha256=S_AQsEw289FIsOgT-OPWL5JZeV8nn5kicwEq0r9qu7s,1071
+devready_cli-0.2.0.dist-info/RECORD,,

devready_cli-0.0.4.dist-info/RECORD

@@ -1,18 +0,0 @@
-devready/__init__.py,sha256=1mptEzQihbdyqqzMgdns_j5ZGK9gz7hR2bsgA_TnjO4,22
-devready/__main__.py,sha256=c-4qpm2SKZs1nENGzSnPnChNTo8iMwjY0XaPyAApn4I,60
-devready/cli.py,sha256=yStxOgFcYqVOVmcbMZGwU83zaZZemecJKGsg0KbVUEE,2521
-devready/explain.py,sha256=PaAt0K0-tdQB5pS9Y2vxZEKChwra_SdY7-qAT0juKto,1765
-devready/mcp_server.py,sha256=zVm89kZL_-pZwTSWkt6rxKonytNklUSa0RCQkX0lzFk,3177
-devready/models.py,sha256=KyGp3ie2LVQmuSfzLV8tbEH_hJyU5-Vi11d0JcQPAuE,646
-devready/runner.py,sha256=5WML6vsoVer0FUpgCderZuqip6ldhWtWGZ-ufVxQV7U,848
-devready/versions.py,sha256=dXKIl1-qvcfadRNaCURMoftwx7YtadDZ-YfUp-85XZc,2112
-devready/checks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-devready/checks/extras.py,sha256=pDJbFaAwjkLc92tcFagOmj-5c_vMx32_MtYa_DBfCz8,3428
-devready/checks/project.py,sha256=UnnjuZmG2aXXBAY45wTEP-bj4CWODMv3DPfEi1V_QDE,5983
-devready/checks/python_check.py,sha256=uQCd-N0LEwt9R5gwZm5mlYiPMST1JXVDNQOdZ5xpako,328
-devready/checks/tools.py,sha256=bjO61jFefp0b6iBHg-a79uaz8nZGCldakfHyB1G8Gf4,1511
-devready_cli-0.0.4.dist-info/METADATA,sha256=UPBgdGDMBm_Uvwzb2vd-ZAhs3EL-rzn7qCCwHgYvHj0,8953
-devready_cli-0.0.4.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-devready_cli-0.0.4.dist-info/entry_points.txt,sha256=7oAecSWtsIt7qLOP8PipOeDqhXCkEJat0oxhD4T1RpY,47
-devready_cli-0.0.4.dist-info/licenses/LICENSE,sha256=S_AQsEw289FIsOgT-OPWL5JZeV8nn5kicwEq0r9qu7s,1071
-devready_cli-0.0.4.dist-info/RECORD,,