doneproof 0.1.0__tar.gz

doneproof-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LRNSdigital (souzalrns)
+
+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.

doneproof-0.1.0/NOTICE

@@ -0,0 +1,9 @@
+doneproof
+Copyright (c) 2026 LRNSdigital (souzalrns). Licensed under the MIT License (see LICENSE).
+
+doneproof has no third-party runtime dependencies. The conditions are plain strings and the
+engine is the Python standard library only (re, pathlib). Nothing is bundled or vendored.
+
+Extracted from the governed runner at github.com/souzalrns/network-agents-setup
+(runner/plan_runner/done_when.py). The runner keeps the glue that binds this engine to its
+event log; this package is the standalone, store-agnostic core.

doneproof-0.1.0/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: doneproof
+Version: 0.1.0
+Summary: Accept a task only when its done-ness is proven by evidence (a file exists, a human gate was resolved) — never the agent's own word. Plain data, zero dependencies, pluggable into any runner or agent.
+Author: LRNSdigital
+License-Expression: MIT
+Project-URL: Repository, https://github.com/souzalrns/network-agents-setup/tree/main/oss/doneproof
+Project-URL: Issues, https://github.com/souzalrns/network-agents-setup/issues
+Keywords: acceptance,done-criteria,evidence,agents,task-completion,verification,claude-code,plugin,automation,gate
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing :: Acceptance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Dynamic: license-file
+
+# doneproof
+
+**Accept a task only when its done-ness is proven by evidence — never the agent's own word.**
+
+An agent (or a plan) declares *doneproof* conditions as plain strings. `doneproof`
+checks each one against real evidence and reports **passed**, **failed** or
+**unverifiable**. Zero dependencies, pure stdlib, pluggable into any runner or agent.
+
+```python
+from pathlib import Path
+from doneproof import evaluate, is_satisfied
+
+result = evaluate(Path("runs/42"), [
+    "artifacts/report.md exists",
+    "human_gate_resolved on publish",
+], gate_resolved=lambda step: step in resolved_steps)
+
+if not is_satisfied(result):
+    raise SystemExit(f"not done: {result['failed']}")
+```
+
+Or from the shell:
+
+```console
+$ doneproof check runs/42 "artifacts/report.md exists" "human_gate_resolved on publish" --resolved publish
+ok   file_exists: artifacts/report.md
+ok   gate_resolved: publish
+doneproof: satisfied (0 failed, 0 unverifiable)
+```
+
+## Why it exists
+
+Most agent frameworks accept `status: done` because the agent *said* it was done.
+That is the failure mode `doneproof` refuses. A task is accepted only when its
+completion is **verifiable**:
+
+| Condition | Evidence checked |
+|-----------|------------------|
+| `<path> exists` | the file exists under the run's root (no `../` escape) |
+| `human_gate_resolved on <step>` | a human approval for `<step>` was recorded |
+
+Everything else is reported as **unverifiable** — not failed. Refusing to fail on
+what you cannot check by evidence is as important as refusing to pass on a say-so.
+The caller decides what to do with the unverifiable bucket (log it, require review,
+or ignore it).
+
+## The gate seam (store-agnostic)
+
+`doneproof` never talks to an event store, queue or database. "Was the gate on
+`<step>` resolved?" is answered by a predicate you pass in:
+
+```python
+evaluate(root, conditions, gate_resolved=lambda step: my_log.approved(step))
+```
+
+Omit it and gates **fail closed** (nothing is considered resolved). This one seam
+is why the same engine runs inside a governed runner and standalone in a test.
+
+## API
+
+- `evaluate(root, conditions, gate_resolved=None) -> dict` — returns
+  `{"passed": [...], "failed": [...], "unverifiable": [...]}`, JSON-serializable.
+  `passed`/`failed` items are `{"kind", "target"}` (kind = `file_exists` |
+  `gate_resolved`); `failed` items also carry `{"condition", "reason"}`.
+- `is_satisfied(result) -> bool` — true iff nothing failed (unverifiable does not fail).
+- `GateResolved` — the `Callable[[str], bool]` type of the gate predicate.
+
+## How it compares
+
+`doneproof` is an **acceptance primitive** for agent/task runs, not a test runner
+or a BDD framework. See `POSITIONING.md` for the evidence-based comparison with
+pytest, BDD (Gherkin) and shell CI gates, and for what it deliberately does not do.
+
+## Install
+
+```console
+pip install doneproof
+```
+
+MIT licensed. Part of the [network-agents-setup](https://github.com/souzalrns/network-agents-setup)
+ecosystem; extracted from its governed runner so any project can accept tasks by evidence.

doneproof-0.1.0/README.md

@@ -0,0 +1,81 @@
+# doneproof
+
+**Accept a task only when its done-ness is proven by evidence — never the agent's own word.**
+
+An agent (or a plan) declares *doneproof* conditions as plain strings. `doneproof`
+checks each one against real evidence and reports **passed**, **failed** or
+**unverifiable**. Zero dependencies, pure stdlib, pluggable into any runner or agent.
+
+```python
+from pathlib import Path
+from doneproof import evaluate, is_satisfied
+
+result = evaluate(Path("runs/42"), [
+    "artifacts/report.md exists",
+    "human_gate_resolved on publish",
+], gate_resolved=lambda step: step in resolved_steps)
+
+if not is_satisfied(result):
+    raise SystemExit(f"not done: {result['failed']}")
+```
+
+Or from the shell:
+
+```console
+$ doneproof check runs/42 "artifacts/report.md exists" "human_gate_resolved on publish" --resolved publish
+ok   file_exists: artifacts/report.md
+ok   gate_resolved: publish
+doneproof: satisfied (0 failed, 0 unverifiable)
+```
+
+## Why it exists
+
+Most agent frameworks accept `status: done` because the agent *said* it was done.
+That is the failure mode `doneproof` refuses. A task is accepted only when its
+completion is **verifiable**:
+
+| Condition | Evidence checked |
+|-----------|------------------|
+| `<path> exists` | the file exists under the run's root (no `../` escape) |
+| `human_gate_resolved on <step>` | a human approval for `<step>` was recorded |
+
+Everything else is reported as **unverifiable** — not failed. Refusing to fail on
+what you cannot check by evidence is as important as refusing to pass on a say-so.
+The caller decides what to do with the unverifiable bucket (log it, require review,
+or ignore it).
+
+## The gate seam (store-agnostic)
+
+`doneproof` never talks to an event store, queue or database. "Was the gate on
+`<step>` resolved?" is answered by a predicate you pass in:
+
+```python
+evaluate(root, conditions, gate_resolved=lambda step: my_log.approved(step))
+```
+
+Omit it and gates **fail closed** (nothing is considered resolved). This one seam
+is why the same engine runs inside a governed runner and standalone in a test.
+
+## API
+
+- `evaluate(root, conditions, gate_resolved=None) -> dict` — returns
+  `{"passed": [...], "failed": [...], "unverifiable": [...]}`, JSON-serializable.
+  `passed`/`failed` items are `{"kind", "target"}` (kind = `file_exists` |
+  `gate_resolved`); `failed` items also carry `{"condition", "reason"}`.
+- `is_satisfied(result) -> bool` — true iff nothing failed (unverifiable does not fail).
+- `GateResolved` — the `Callable[[str], bool]` type of the gate predicate.
+
+## How it compares
+
+`doneproof` is an **acceptance primitive** for agent/task runs, not a test runner
+or a BDD framework. See `POSITIONING.md` for the evidence-based comparison with
+pytest, BDD (Gherkin) and shell CI gates, and for what it deliberately does not do.
+
+## Install
+
+```console
+pip install doneproof
+```
+
+MIT licensed. Part of the [network-agents-setup](https://github.com/souzalrns/network-agents-setup)
+ecosystem; extracted from its governed runner so any project can accept tasks by evidence.

doneproof-0.1.0/pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "doneproof"
+version = "0.1.0"
+description = "Accept a task only when its done-ness is proven by evidence (a file exists, a human gate was resolved) — never the agent's own word. Plain data, zero dependencies, pluggable into any runner or agent."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE", "NOTICE"]
+requires-python = ">=3.10"
+authors = [{ name = "LRNSdigital" }]
+keywords = [
+  "acceptance", "done-criteria", "evidence", "agents", "task-completion",
+  "verification", "claude-code", "plugin", "automation", "gate",
+]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Quality Assurance",
+  "Topic :: Software Development :: Testing :: Acceptance",
+]
+# Zero runtime dependencies: the conditions are plain strings, the engine is pure stdlib.
+dependencies = []
+
+[project.optional-dependencies]
+test = ["pytest>=8"]
+
+[project.scripts]
+doneproof = "doneproof.cli:main"
+
+[project.urls]
+Repository = "https://github.com/souzalrns/network-agents-setup/tree/main/oss/doneproof"
+Issues = "https://github.com/souzalrns/network-agents-setup/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+doneproof = ["py.typed"]  # PEP 561: ships its own types
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "B", "UP", "S", "RUF"]
+ignore = ["RUF001", "RUF002", "RUF003"]  # intentional unicode arrows/dashes in messages
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["S101", "S108"]

doneproof-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

doneproof-0.1.0/src/doneproof/__init__.py

@@ -0,0 +1,102 @@
+"""doneproof: accept a task only when its done-ness is proven by evidence.
+
+An agent (or a plan) declares *doneproof* conditions in plain strings. This
+package classifies each one as **passed**, **failed** or **unverifiable** by
+checking real evidence — never the agent's own word that it finished.
+
+Two evidence kinds are understood (the only two that verify without
+interpreting free text):
+
+- ``<path> exists`` — the file exists under the run's root directory. The path
+  is resolved and must stay inside the root (no ``../`` escape).
+- ``human_gate_resolved on <step>`` — a human approval for ``<step>`` was
+  recorded. "Was it recorded?" is answered by a caller-supplied predicate
+  (``gate_resolved``), so this package never depends on any particular event
+  store, queue or database.
+
+A condition in any other shape is **not failed** — it is reported as
+``unverifiable`` so the caller can decide. Refusing to fail on what you cannot
+check by evidence is as important as refusing to pass on an agent's say-so.
+
+    from pathlib import Path
+    from doneproof import evaluate, is_satisfied
+
+    result = evaluate(Path("runs/42"), ["artifacts/report.md exists"])
+    assert is_satisfied(result)
+
+The return value is a plain JSON-serializable dict so it drops straight into a
+log or an event. ``is_satisfied`` is true iff there are no failures;
+unverifiable conditions do not make a run fail.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+__version__ = "0.1.0"
+
+__all__ = ["GateResolved", "__version__", "evaluate", "is_satisfied"]
+
+# "Was the human gate on <step> resolved?" — the one thing this package cannot
+# check from the filesystem. The caller supplies it (bound to its own event log,
+# queue, DB, …). Default: nothing is resolved, so gate conditions fail closed.
+GateResolved = Callable[[str], bool]
+
+_EXISTS = re.compile(r"^(?P<path>\S+)\s+exists$")
+_GATE = re.compile(r"^human_gate_resolved\s+on\s+(?P<step>\S+)$")
+
+
+def evaluate(
+    root: str | Path,
+    conditions: list[str],
+    gate_resolved: GateResolved | None = None,
+) -> dict[str, list[Any]]:
+    """Classify each condition into ``passed``, ``failed`` or ``unverifiable``.
+
+    ``root`` is the run directory that ``<path> exists`` conditions resolve
+    against; a path that escapes it fails. ``gate_resolved(step) -> bool``
+    answers ``human_gate_resolved on <step>``; when omitted, no gate is
+    considered resolved (fail-closed).
+
+    Returns ``{"passed": [...], "failed": [...], "unverifiable": [...]}``.
+    ``passed`` and ``failed`` items are ``{"kind", "target"}``
+    (kind = ``file_exists`` | ``gate_resolved``); ``failed`` items also carry
+    ``{"condition", "reason"}``. ``unverifiable`` keeps the original strings.
+    Passed items omit the original text so a reader scanning for the literal
+    ``human_gate_resolved`` does not confuse an accepted condition with the
+    real approval event.
+    """
+    resolved = gate_resolved if gate_resolved is not None else (lambda _step: False)
+    result: dict[str, list[Any]] = {"passed": [], "failed": [], "unverifiable": []}
+    base = Path(root).resolve()
+    for raw in conditions:
+        cond = str(raw).strip()
+        m = _EXISTS.match(cond)
+        if m:
+            item = {"kind": "file_exists", "target": m.group("path")}
+            target = (base / m.group("path")).resolve()
+            if not target.is_relative_to(base):
+                result["failed"].append({**item, "condition": cond, "reason": "path outside the run directory"})
+            elif target.is_file():
+                result["passed"].append(item)
+            else:
+                result["failed"].append({**item, "condition": cond, "reason": "file missing"})
+            continue
+        m = _GATE.match(cond)
+        if m:
+            item = {"kind": "gate_resolved", "target": m.group("step")}
+            if resolved(m.group("step")):
+                result["passed"].append(item)
+            else:
+                result["failed"].append({**item, "condition": cond, "reason": "gate not resolved"})
+            continue
+        result["unverifiable"].append(cond)
+    return result
+
+
+def is_satisfied(result: dict[str, list[Any]]) -> bool:
+    """True iff nothing failed. Unverifiable conditions do not fail a run."""
+    return not result["failed"]

doneproof-0.1.0/src/doneproof/cli.py

@@ -0,0 +1,53 @@
+"""doneproof CLI: check acceptance conditions by evidence, exit 0/1.
+
+    doneproof check <root> [CONDITION ...] [--resolved STEP ...] [--json]
+
+Exit 0 when nothing failed (unverifiable conditions do not fail), 1 otherwise.
+``--resolved STEP`` marks a human gate as resolved (repeatable); without it,
+``human_gate_resolved on <step>`` fails closed. ``--json`` prints the full
+structured result instead of the human summary.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from . import __version__, evaluate, is_satisfied
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(prog="doneproof", description=__doc__.splitlines()[0])
+    ap.add_argument("--version", action="version", version=f"doneproof {__version__}")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    c = sub.add_parser("check", help="Check conditions against evidence under <root>")
+    c.add_argument("root", help="The run directory that `<path> exists` resolves against")
+    c.add_argument("conditions", nargs="*", help="doneproof conditions, e.g. 'artifacts/r.md exists'")
+    c.add_argument(
+        "--resolved", action="append", default=[], metavar="STEP", help="Mark a human gate as resolved (repeatable)"
+    )
+    c.add_argument("--json", action="store_true", help="Print the full structured result")
+    args = ap.parse_args(argv)
+
+    resolved = set(args.resolved)
+    result = evaluate(args.root, args.conditions, gate_resolved=lambda step: step in resolved)
+
+    if args.json:
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+    else:
+        for item in result["passed"]:
+            print(f"ok   {item['kind']}: {item['target']}")
+        for item in result["failed"]:
+            print(f"FAIL {item['kind']}: {item['target']} ({item['reason']})")
+        for cond in result["unverifiable"]:
+            print(f"?    unverifiable: {cond}")
+        print(
+            f"doneproof: {'satisfied' if is_satisfied(result) else 'FAILED'} "
+            f"({len(result['failed'])} failed, {len(result['unverifiable'])} unverifiable)"
+        )
+    return 0 if is_satisfied(result) else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

doneproof-0.1.0/src/doneproof.egg-info/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: doneproof
+Version: 0.1.0
+Summary: Accept a task only when its done-ness is proven by evidence (a file exists, a human gate was resolved) — never the agent's own word. Plain data, zero dependencies, pluggable into any runner or agent.
+Author: LRNSdigital
+License-Expression: MIT
+Project-URL: Repository, https://github.com/souzalrns/network-agents-setup/tree/main/oss/doneproof
+Project-URL: Issues, https://github.com/souzalrns/network-agents-setup/issues
+Keywords: acceptance,done-criteria,evidence,agents,task-completion,verification,claude-code,plugin,automation,gate
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing :: Acceptance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Dynamic: license-file
+
+# doneproof
+
+**Accept a task only when its done-ness is proven by evidence — never the agent's own word.**
+
+An agent (or a plan) declares *doneproof* conditions as plain strings. `doneproof`
+checks each one against real evidence and reports **passed**, **failed** or
+**unverifiable**. Zero dependencies, pure stdlib, pluggable into any runner or agent.
+
+```python
+from pathlib import Path
+from doneproof import evaluate, is_satisfied
+
+result = evaluate(Path("runs/42"), [
+    "artifacts/report.md exists",
+    "human_gate_resolved on publish",
+], gate_resolved=lambda step: step in resolved_steps)
+
+if not is_satisfied(result):
+    raise SystemExit(f"not done: {result['failed']}")
+```
+
+Or from the shell:
+
+```console
+$ doneproof check runs/42 "artifacts/report.md exists" "human_gate_resolved on publish" --resolved publish
+ok   file_exists: artifacts/report.md
+ok   gate_resolved: publish
+doneproof: satisfied (0 failed, 0 unverifiable)
+```
+
+## Why it exists
+
+Most agent frameworks accept `status: done` because the agent *said* it was done.
+That is the failure mode `doneproof` refuses. A task is accepted only when its
+completion is **verifiable**:
+
+| Condition | Evidence checked |
+|-----------|------------------|
+| `<path> exists` | the file exists under the run's root (no `../` escape) |
+| `human_gate_resolved on <step>` | a human approval for `<step>` was recorded |
+
+Everything else is reported as **unverifiable** — not failed. Refusing to fail on
+what you cannot check by evidence is as important as refusing to pass on a say-so.
+The caller decides what to do with the unverifiable bucket (log it, require review,
+or ignore it).
+
+## The gate seam (store-agnostic)
+
+`doneproof` never talks to an event store, queue or database. "Was the gate on
+`<step>` resolved?" is answered by a predicate you pass in:
+
+```python
+evaluate(root, conditions, gate_resolved=lambda step: my_log.approved(step))
+```
+
+Omit it and gates **fail closed** (nothing is considered resolved). This one seam
+is why the same engine runs inside a governed runner and standalone in a test.
+
+## API
+
+- `evaluate(root, conditions, gate_resolved=None) -> dict` — returns
+  `{"passed": [...], "failed": [...], "unverifiable": [...]}`, JSON-serializable.
+  `passed`/`failed` items are `{"kind", "target"}` (kind = `file_exists` |
+  `gate_resolved`); `failed` items also carry `{"condition", "reason"}`.
+- `is_satisfied(result) -> bool` — true iff nothing failed (unverifiable does not fail).
+- `GateResolved` — the `Callable[[str], bool]` type of the gate predicate.
+
+## How it compares
+
+`doneproof` is an **acceptance primitive** for agent/task runs, not a test runner
+or a BDD framework. See `POSITIONING.md` for the evidence-based comparison with
+pytest, BDD (Gherkin) and shell CI gates, and for what it deliberately does not do.
+
+## Install
+
+```console
+pip install doneproof
+```
+
+MIT licensed. Part of the [network-agents-setup](https://github.com/souzalrns/network-agents-setup)
+ecosystem; extracted from its governed runner so any project can accept tasks by evidence.

doneproof-0.1.0/src/doneproof.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+NOTICE
+README.md
+pyproject.toml
+src/doneproof/__init__.py
+src/doneproof/cli.py
+src/doneproof/py.typed
+src/doneproof.egg-info/PKG-INFO
+src/doneproof.egg-info/SOURCES.txt
+src/doneproof.egg-info/dependency_links.txt
+src/doneproof.egg-info/entry_points.txt
+src/doneproof.egg-info/requires.txt
+src/doneproof.egg-info/top_level.txt
+tests/test_doneproof.py

doneproof-0.1.0/src/doneproof.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

doneproof-0.1.0/src/doneproof.egg-info/entry_points.txt

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

doneproof-0.1.0/src/doneproof.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[test]
+pytest>=8

doneproof-0.1.0/src/doneproof.egg-info/top_level.txt

@@ -0,0 +1 @@
+doneproof

doneproof-0.1.0/tests/test_doneproof.py

@@ -0,0 +1,135 @@
+"""doneproof: acceptance by evidence (the two verifiable forms + unverifiable)."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from doneproof import evaluate, is_satisfied
+from doneproof.cli import main
+
+# ---- form 1: "<path> exists"
+
+
+def test_exists_passes_when_file_present(tmp_path):
+    (tmp_path / "artifacts").mkdir()
+    (tmp_path / "artifacts" / "r.md").write_text("x", encoding="utf-8")
+    r = evaluate(tmp_path, ["artifacts/r.md exists"])
+    assert r == {"passed": [{"kind": "file_exists", "target": "artifacts/r.md"}], "failed": [], "unverifiable": []}
+    assert is_satisfied(r)
+
+
+def test_exists_fails_with_reason_when_missing(tmp_path):
+    r = evaluate(tmp_path, ["artifacts/zz.md exists"])
+    assert r["passed"] == [] and r["unverifiable"] == []
+    assert r["failed"] == [
+        {
+            "kind": "file_exists",
+            "target": "artifacts/zz.md",
+            "condition": "artifacts/zz.md exists",
+            "reason": "file missing",
+        }
+    ]
+    assert not is_satisfied(r)
+
+
+def test_exists_outside_root_fails(tmp_path):
+    r = evaluate(tmp_path, ["../secret.md exists"])
+    assert r["failed"][0]["reason"] == "path outside the run directory"
+    assert not is_satisfied(r)
+
+
+def test_directory_is_not_a_file(tmp_path):
+    (tmp_path / "artifacts").mkdir()
+    r = evaluate(tmp_path, ["artifacts exists"])
+    assert r["failed"][0]["reason"] == "file missing"
+
+
+# ---- form 2: "human_gate_resolved on <step>"
+
+
+def test_gate_passes_when_resolver_says_so(tmp_path):
+    r = evaluate(tmp_path, ["human_gate_resolved on hitl"], gate_resolved=lambda step: step == "hitl")
+    assert r["passed"] == [{"kind": "gate_resolved", "target": "hitl"}]
+    assert is_satisfied(r)
+
+
+def test_gate_fails_closed_by_default(tmp_path):
+    r = evaluate(tmp_path, ["human_gate_resolved on hitl"])
+    assert r["failed"] == [
+        {
+            "kind": "gate_resolved",
+            "target": "hitl",
+            "condition": "human_gate_resolved on hitl",
+            "reason": "gate not resolved",
+        }
+    ]
+
+
+def test_passed_items_drop_the_literal_gate_text(tmp_path):
+    """A reader scanning for 'human_gate_resolved' must not match an accepted condition."""
+    r = evaluate(tmp_path, ["human_gate_resolved on hitl"], gate_resolved=lambda _s: True)
+    assert "human_gate_resolved" not in json.dumps(r["passed"])
+
+
+# ---- form 3: unverifiable — reported, never failed
+
+
+def test_unknown_shape_is_unverifiable_not_failed(tmp_path):
+    cond = "no ad_account_mutation without approve"
+    r = evaluate(tmp_path, [cond, "x.md exists"])
+    assert r["unverifiable"] == [cond]
+    # the free-text condition does not fail the set; only the missing file does
+    assert [f["kind"] for f in r["failed"]] == ["file_exists"]
+
+
+def test_empty_conditions_is_satisfied(tmp_path):
+    assert evaluate(tmp_path, []) == {"passed": [], "failed": [], "unverifiable": []}
+    assert is_satisfied(evaluate(tmp_path, []))
+
+
+# ---- autonomy test: no event store, no external deps
+
+
+def test_runs_with_no_gate_resolver_and_pure_stdlib(tmp_path):
+    (tmp_path / "a").write_text("1", encoding="utf-8")
+    r = evaluate(tmp_path, ["a exists", "human_gate_resolved on g", "free text"])
+    assert r["passed"] == [{"kind": "file_exists", "target": "a"}]
+    assert r["failed"][0]["kind"] == "gate_resolved"
+    assert r["unverifiable"] == ["free text"]
+
+
+# ---- CLI
+
+
+def test_cli_exit_0_when_satisfied(tmp_path, capsys):
+    (tmp_path / "a").write_text("1", encoding="utf-8")
+    assert main(["check", str(tmp_path), "a exists"]) == 0
+    assert "satisfied" in capsys.readouterr().out
+
+
+def test_cli_exit_1_when_failed(tmp_path, capsys):
+    assert main(["check", str(tmp_path), "missing exists"]) == 1
+    assert "FAILED" in capsys.readouterr().out
+
+
+def test_cli_resolved_flag(tmp_path):
+    assert main(["check", str(tmp_path), "human_gate_resolved on hitl", "--resolved", "hitl"]) == 0
+
+
+def test_cli_unverifiable_does_not_fail(tmp_path):
+    assert main(["check", str(tmp_path), "something free"]) == 0
+
+
+def test_cli_json_output(tmp_path, capsys):
+    main(["check", str(tmp_path), "missing exists", "--json"])
+    out = json.loads(capsys.readouterr().out)
+    assert out["failed"][0]["target"] == "missing"
+
+
+def test_cli_version(capsys):
+    with pytest.raises(SystemExit) as e:
+        main(["--version"])
+    assert e.value.code == 0
+    assert "doneproof" in capsys.readouterr().out