proof-engine-wiki 1.33.0__tar.gz

proof_engine_wiki-1.33.0/LICENSE

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

proof_engine_wiki-1.33.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: proof-engine-wiki
+Version: 1.33.0
+Summary: Attach verified Proof Engine proofs to LLM-wiki claims.
+Author-email: Yaniv Golan <yaniv@lool.vc>
+License: MIT License
+        
+        Copyright (c) 2026 Yaniv Golan
+        
+        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.
+        
+Project-URL: Homepage, https://proofengine.info
+Project-URL: Repository, https://github.com/yaniv-golan/proof-engine
+Project-URL: Documentation, https://github.com/yaniv-golan/proof-engine/blob/main/packages/proof-engine-wiki/README.md
+Project-URL: Issues, https://github.com/yaniv-golan/proof-engine/issues
+Project-URL: Changelog, https://github.com/yaniv-golan/proof-engine/blob/main/CHANGELOG.md
+Project-URL: Source, https://github.com/yaniv-golan/proof-engine/tree/main/packages/proof-engine-wiki
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: proof-citations>=0.1
+Requires-Dist: proof-engine-registry>=0.1
+Requires-Dist: requests>=2.31
+Dynamic: license-file
+
+# proof-engine-wiki
+
+Attach Proof Engine proofs to LLM-wiki claims.
+
+## Install
+
+    pip install proof-engine-wiki
+
+## Marker syntax
+
+Authors mark claims they want proven:
+
+    The US dollar has {{prove: lost 15% of its purchasing power since 2020}}.
+
+## Ingest
+
+    proof-engine-wiki ingest PAGE.md
+
+Extracts all `{{prove:}}` markers, looks up configured registries,
+commissions a new proof only for misses, rewrites the file with inline
+badges and links.
+
+## Lint
+
+    proof-engine-wiki lint WIKI_DIR/
+
+Scans every `.md` file under the directory and reports:
+
+- `unresolved_marker` — `{{prove:}}` markers in the page that haven't
+  been resolved yet (run `ingest` to resolve them).
+- `stale_proof` — embedded proof URLs that no longer respond to a HEAD
+  request (the proof was retracted or the registry moved).
+
+Pass `--skip-network` to suppress URL reachability checks (faster CI;
+catches only `unresolved_marker`).
+
+## Registry-only mode
+
+Add `--registry-only` to `ingest` to skip new-proof commissioning
+entirely. Useful for CI: if every `{{prove:}}` claim already has a
+registered proof, ingest runs offline and quickly. Misses are reported,
+not commissioned.

proof_engine_wiki-1.33.0/README.md

@@ -0,0 +1,42 @@
+# proof-engine-wiki
+
+Attach Proof Engine proofs to LLM-wiki claims.
+
+## Install
+
+    pip install proof-engine-wiki
+
+## Marker syntax
+
+Authors mark claims they want proven:
+
+    The US dollar has {{prove: lost 15% of its purchasing power since 2020}}.
+
+## Ingest
+
+    proof-engine-wiki ingest PAGE.md
+
+Extracts all `{{prove:}}` markers, looks up configured registries,
+commissions a new proof only for misses, rewrites the file with inline
+badges and links.
+
+## Lint
+
+    proof-engine-wiki lint WIKI_DIR/
+
+Scans every `.md` file under the directory and reports:
+
+- `unresolved_marker` — `{{prove:}}` markers in the page that haven't
+  been resolved yet (run `ingest` to resolve them).
+- `stale_proof` — embedded proof URLs that no longer respond to a HEAD
+  request (the proof was retracted or the registry moved).
+
+Pass `--skip-network` to suppress URL reachability checks (faster CI;
+catches only `unresolved_marker`).
+
+## Registry-only mode
+
+Add `--registry-only` to `ingest` to skip new-proof commissioning
+entirely. Useful for CI: if every `{{prove:}}` claim already has a
+registered proof, ingest runs offline and quickly. Misses are reported,
+not commissioned.

proof_engine_wiki-1.33.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "proof-engine-wiki"
+version = "1.33.0"
+description = "Attach verified Proof Engine proofs to LLM-wiki claims."
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [{ name = "Yaniv Golan", email = "yaniv@lool.vc" }]
+requires-python = ">=3.11"
+dependencies = [
+  "proof-citations>=0.1",
+  "proof-engine-registry>=0.1",
+  "requests>=2.31",
+]
+
+[project.scripts]
+proof-engine-wiki = "proof_engine_wiki.cli:main"
+
+[project.urls]
+Homepage = "https://proofengine.info"
+Repository = "https://github.com/yaniv-golan/proof-engine"
+Documentation = "https://github.com/yaniv-golan/proof-engine/blob/main/packages/proof-engine-wiki/README.md"
+Issues = "https://github.com/yaniv-golan/proof-engine/issues"
+Changelog = "https://github.com/yaniv-golan/proof-engine/blob/main/CHANGELOG.md"
+Source = "https://github.com/yaniv-golan/proof-engine/tree/main/packages/proof-engine-wiki"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

proof_engine_wiki-1.33.0/setup.cfg

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

proof_engine_wiki-1.33.0/src/proof_engine_wiki/__init__.py

@@ -0,0 +1,3 @@
+"""proof-engine-wiki: attach Proof Engine proofs to LLM-wiki claims."""
+
+__version__ = "1.33.0"

proof_engine_wiki-1.33.0/src/proof_engine_wiki/cli.py

@@ -0,0 +1,101 @@
+"""proof-engine-wiki CLI: ingest | lint."""
+
+from __future__ import annotations
+
+import argparse
+import dataclasses
+import json
+import sys
+from pathlib import Path
+
+try:
+    from proof_engine_wiki import __version__
+except ImportError:
+    __version__ = "0.1.0"
+
+from proof_engine_wiki.ingest import ingest_page
+from proof_engine_wiki.lint import lint_wiki
+
+
+def _cmd_ingest(args) -> int:
+    result = ingest_page(
+        Path(args.path),
+        registry_only=args.registry_only,
+        dry_run=args.dry_run,
+        model=args.model,
+    )
+    payload = {
+        "path": str(result.path),
+        "markers": len(result.markers),
+        "resolved_from_registry": result.resolved_from_registry,
+        "generated": result.generated,
+        "misses": result.misses,
+        "errors": result.errors,
+    }
+    if args.json:
+        sys.stdout.write(json.dumps(payload, indent=2 if args.pretty else None) + "\n")
+    else:
+        sys.stdout.write(
+            f"{result.path}: {len(result.markers)} markers, "
+            f"{result.resolved_from_registry} resolved, "
+            f"{result.generated} generated, "
+            f"{result.misses} misses\n"
+        )
+    return 0 if result.misses == 0 and not result.errors else 1
+
+
+def _cmd_lint(args) -> int:
+    findings = lint_wiki(Path(args.path), skip_network=args.skip_network)
+    payload = {
+        "path": str(args.path),
+        "findings": [
+            {
+                "path": str(f.path), "line": f.line,
+                "kind": f.kind, "message": f.message, "detail": f.detail,
+            }
+            for f in findings
+        ],
+    }
+    if args.json:
+        sys.stdout.write(json.dumps(payload, indent=2 if args.pretty else None) + "\n")
+    else:
+        for f in findings:
+            sys.stdout.write(f"{f.path}:{f.line}: [{f.kind}] {f.message}\n")
+        if not findings:
+            sys.stdout.write("clean\n")
+    return 0 if not findings else 1
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="proof-engine-wiki")
+    p.add_argument("--version", action="version", version=__version__)
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    ing = sub.add_parser("ingest", help="Extract {{prove:}} markers and resolve them.")
+    ing.add_argument("path")
+    ing.add_argument("--registry-only", action="store_true")
+    ing.add_argument("--dry-run", action="store_true")
+    ing.add_argument("--model", default="sonnet")
+    ing.add_argument("--json", action="store_true")
+    ing.add_argument("--pretty", action="store_true")
+    ing.set_defaults(func=_cmd_ingest)
+
+    lnt = sub.add_parser("lint", help="Scan a wiki for unresolved markers and stale proofs.")
+    lnt.add_argument("path")
+    lnt.add_argument("--skip-network", action="store_true",
+                     help="Skip URL reachability checks.")
+    lnt.add_argument("--json", action="store_true")
+    lnt.add_argument("--pretty", action="store_true")
+    lnt.set_defaults(func=_cmd_lint)
+
+    return p
+
+
+def main(argv=None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

proof_engine_wiki-1.33.0/src/proof_engine_wiki/ingest.py

@@ -0,0 +1,138 @@
+"""Ingest: extract {{prove:}} markers, resolve or commission, rewrite page."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+from proof_engine_registry.client import RegistryClient, LookupHit
+from proof_engine_registry.config import Registry, load_registries
+
+from proof_engine_wiki.markers import Marker, find_markers, replace_markers
+
+
+@dataclass
+class IngestResult:
+    path: Path
+    markers: list[Marker]
+    resolved_from_registry: int = 0
+    generated: int = 0
+    misses: int = 0
+    errors: list[str] = field(default_factory=list)
+
+
+def _hit_to_embed(hit: LookupHit, claim_text: str) -> str:
+    """Format a successful lookup as inline Markdown: link + badge."""
+    return (
+        f"[{claim_text}]({hit.proof_url}) "
+        f"![proof]({hit.badge_url.replace('.json', '.svg')})"
+    )
+
+
+def ingest_page(
+    path: Path,
+    registries: Optional[list[Registry]] = None,
+    *,
+    registry_only: bool = False,
+    dry_run: bool = False,
+    model: str = "sonnet",
+    proof_output_base: Optional[Path] = None,
+) -> IngestResult:
+    path = Path(path)
+    original_text = path.read_text()
+    markers = find_markers(original_text)
+
+    result = IngestResult(path=path, markers=markers)
+    if not markers:
+        return result
+
+    regs = registries if registries is not None else load_registries()
+    client = RegistryClient(regs) if regs else None
+
+    replacements: dict[tuple[int, int], str] = {}
+
+    for m in markers:
+        hit = client.lookup(m.claim) if client else None
+        if hit is not None:
+            replacements[m.span] = _hit_to_embed(hit, m.claim)
+            result.resolved_from_registry += 1
+            continue
+
+        if registry_only:
+            result.misses += 1
+            continue
+
+        # Commission a new proof via the Proof Engine verify CLI.
+        if proof_output_base is None:
+            proof_output_base = path.parent / ".proofs"
+        proof_output_base.mkdir(parents=True, exist_ok=True)
+        output_dir = proof_output_base / _slugify(m.claim)
+
+        verdict = _invoke_verify(m.claim, model, output_dir)
+        if verdict is None:
+            result.errors.append(f"verify failed for: {m.claim[:80]}")
+            result.misses += 1
+            continue
+
+        # After generation, the proof isn't yet in any registry; produce a
+        # local link to the output dir until the user publishes.
+        embed = (
+            f"[{m.claim}]({output_dir.as_posix()}/proof.md) "
+            f"<!-- Proof generated; run `proof-engine-wiki publish "
+            f"{output_dir}` to add to your registry. -->"
+        )
+        replacements[m.span] = embed
+        result.generated += 1
+
+    if replacements and not dry_run:
+        new_text = replace_markers(original_text, replacements)
+        path.write_text(new_text)
+
+    return result
+
+
+def _slugify(text: str) -> str:
+    import re
+    s = re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")
+    return s[:60] or "claim"
+
+
+def _invoke_verify(claim: str, model: str, output_dir: Path) -> Optional[dict]:
+    """Call `proof-engine verify` and parse the JSON verdict."""
+    import json
+    script = _find_verify_cli()
+    if script is None:
+        return None
+    proc = subprocess.run(
+        [sys.executable, str(script),
+         "--claim", claim,
+         "--model", model,
+         "--output-dir", str(output_dir),
+         "--json"],
+        capture_output=True, text=True,
+    )
+    if not proc.stdout:
+        return None
+    try:
+        return json.loads(proc.stdout)
+    except json.JSONDecodeError:
+        return None
+
+
+def _find_verify_cli() -> Optional[Path]:
+    """Locate the verify_cli.py script. Search the same repo first."""
+    import os
+    env_path = os.environ.get("PROOF_ENGINE_VERIFY_CLI")
+    if env_path:
+        p = Path(env_path)
+        if p.exists():
+            return p
+    # Walk up from this file looking for tools/verify_cli.py in the repo.
+    for parent in Path(__file__).resolve().parents:
+        candidate = parent / "tools" / "verify_cli.py"
+        if candidate.exists():
+            return candidate
+    return None

proof_engine_wiki-1.33.0/src/proof_engine_wiki/lint.py

@@ -0,0 +1,76 @@
+"""Lint a wiki directory: unresolved markers, stale proofs, broken badges."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from proof_engine_wiki.markers import find_markers
+
+
+_PROOF_LINK_RE = re.compile(
+    r"\[([^\]]+)\]\((?P<url>https?://[^)]+/proofs/[^)]+/)\)"
+)
+_BADGE_IMG_RE = re.compile(
+    r"!\[proof\]\((?P<url>https?://[^)]+/badge\.svg)\)"
+)
+
+
+@dataclass(frozen=True)
+class LintFinding:
+    path: Path
+    line: int
+    kind: str          # unresolved_marker | stale_proof | badge_unreachable
+    message: str
+    detail: str = ""
+
+
+def lint_wiki(
+    root: Path,
+    *,
+    skip_network: bool = False,
+) -> list[LintFinding]:
+    root = Path(root)
+    findings: list[LintFinding] = []
+    for md in sorted(root.rglob("*.md")):
+        findings.extend(_lint_file(md, skip_network=skip_network))
+    return findings
+
+
+def _lint_file(path: Path, *, skip_network: bool) -> list[LintFinding]:
+    text = path.read_text()
+    out: list[LintFinding] = []
+
+    # Unresolved markers.
+    for m in find_markers(text):
+        line = text[: m.span[0]].count("\n") + 1
+        out.append(LintFinding(
+            path=path, line=line,
+            kind="unresolved_marker",
+            message=f"unresolved {{{{prove:}}}} marker",
+            detail=m.claim,
+        ))
+
+    # Optionally verify each embedded proof link is still reachable.
+    if not skip_network:
+        for m in _PROOF_LINK_RE.finditer(text):
+            url = m.group("url")
+            if not _url_alive(url):
+                line = text[: m.start()].count("\n") + 1
+                out.append(LintFinding(
+                    path=path, line=line,
+                    kind="stale_proof",
+                    message=f"proof URL not reachable: {url}",
+                ))
+
+    return out
+
+
+def _url_alive(url: str, timeout: float = 5.0) -> bool:
+    import requests
+    try:
+        r = requests.head(url, timeout=timeout, allow_redirects=True)
+        return r.status_code < 400
+    except Exception:
+        return False

proof_engine_wiki-1.33.0/src/proof_engine_wiki/markers.py

@@ -0,0 +1,90 @@
+"""Parser and rewriter for `{{prove: ...}}` markers in wiki prose.
+
+Markers are the explicit signal from the author to attach a proof to a claim.
+They are regex-greppable by design — no NLP needed at this layer.
+
+Markers inside fenced code blocks (``` ... ```), inline HTML comments
+(<!-- ... -->), and YAML frontmatter at the top of the file are masked
+before matching. Wiki authors who write prose ABOUT the marker syntax
+(documenting it, showing examples) should not accidentally commission a proof.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+
+# Non-greedy match, allows any content between `prove:` and `}}`, including
+# punctuation. Does NOT cross paragraph boundaries (no `\n\n`).
+_PATTERN = re.compile(
+    r"\{\{\s*prove\s*:\s*(?P<claim>(?:(?!\}\}|\n\n).)+?)\s*\}\}",
+    re.DOTALL,
+)
+
+# Masking patterns — each matches a region in which markers should be ignored.
+_CODE_FENCE = re.compile(r"```.*?```", re.DOTALL)
+_INLINE_CODE = re.compile(r"`[^`\n]+`")
+_HTML_COMMENT = re.compile(r"<!--.*?-->", re.DOTALL)
+# YAML frontmatter: leading `---\n...\n---` at file start.
+_FRONTMATTER = re.compile(r"\A---\n.*?\n---\n", re.DOTALL)
+
+
+@dataclass(frozen=True)
+class Marker:
+    claim: str
+    # Half-open range in the source text: text[span[0]:span[1]] equals the
+    # full `{{prove: ...}}` marker. Matches re.Match.start()/end() semantics.
+    span: tuple[int, int]
+
+
+def _mask_excluded_regions(text: str) -> str:
+    """Return text with excluded regions replaced by spaces of the same length.
+
+    Same-length replacement preserves offsets so downstream span arithmetic
+    still matches the original text.
+    """
+    out = list(text)
+    for pat in (_FRONTMATTER, _CODE_FENCE, _INLINE_CODE, _HTML_COMMENT):
+        for m in pat.finditer(text):
+            for i in range(m.start(), m.end()):
+                # Keep newlines to preserve line numbers in lint output.
+                if out[i] != "\n":
+                    out[i] = " "
+    return "".join(out)
+
+
+def find_markers(text: str) -> list[Marker]:
+    """Find `{{prove: ...}}` markers, skipping code blocks, comments, frontmatter."""
+    masked = _mask_excluded_regions(text)
+    out: list[Marker] = []
+    for m in _PATTERN.finditer(masked):
+        # Claim text must come from the ORIGINAL string, not the masked copy —
+        # a marker that straddles into an inline code span would be masked,
+        # but a marker fully outside gives the correct claim text from `text`.
+        claim = text[m.start():m.end()]
+        # Re-parse the claim out of the full marker with the same pattern.
+        inner = _PATTERN.fullmatch(claim)
+        if inner is None:
+            continue
+        out.append(Marker(
+            claim=inner.group("claim").strip(),
+            span=(m.start(), m.end()),
+        ))
+    return out
+
+
+def replace_markers(text: str, replacements: dict[tuple[int, int], str]) -> str:
+    """Replace each (start, end) span with the given string.
+
+    Spans must not overlap. Iterates back-to-front so earlier spans aren't
+    invalidated by replacements.
+    """
+    if not replacements:
+        return text
+    sorted_spans = sorted(replacements.keys(), key=lambda s: s[0], reverse=True)
+    out = text
+    for span in sorted_spans:
+        start, end = span
+        out = out[:start] + replacements[span] + out[end:]
+    return out

proof_engine_wiki-1.33.0/src/proof_engine_wiki.egg-info/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: proof-engine-wiki
+Version: 1.33.0
+Summary: Attach verified Proof Engine proofs to LLM-wiki claims.
+Author-email: Yaniv Golan <yaniv@lool.vc>
+License: MIT License
+        
+        Copyright (c) 2026 Yaniv Golan
+        
+        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.
+        
+Project-URL: Homepage, https://proofengine.info
+Project-URL: Repository, https://github.com/yaniv-golan/proof-engine
+Project-URL: Documentation, https://github.com/yaniv-golan/proof-engine/blob/main/packages/proof-engine-wiki/README.md
+Project-URL: Issues, https://github.com/yaniv-golan/proof-engine/issues
+Project-URL: Changelog, https://github.com/yaniv-golan/proof-engine/blob/main/CHANGELOG.md
+Project-URL: Source, https://github.com/yaniv-golan/proof-engine/tree/main/packages/proof-engine-wiki
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: proof-citations>=0.1
+Requires-Dist: proof-engine-registry>=0.1
+Requires-Dist: requests>=2.31
+Dynamic: license-file
+
+# proof-engine-wiki
+
+Attach Proof Engine proofs to LLM-wiki claims.
+
+## Install
+
+    pip install proof-engine-wiki
+
+## Marker syntax
+
+Authors mark claims they want proven:
+
+    The US dollar has {{prove: lost 15% of its purchasing power since 2020}}.
+
+## Ingest
+
+    proof-engine-wiki ingest PAGE.md
+
+Extracts all `{{prove:}}` markers, looks up configured registries,
+commissions a new proof only for misses, rewrites the file with inline
+badges and links.
+
+## Lint
+
+    proof-engine-wiki lint WIKI_DIR/
+
+Scans every `.md` file under the directory and reports:
+
+- `unresolved_marker` — `{{prove:}}` markers in the page that haven't
+  been resolved yet (run `ingest` to resolve them).
+- `stale_proof` — embedded proof URLs that no longer respond to a HEAD
+  request (the proof was retracted or the registry moved).
+
+Pass `--skip-network` to suppress URL reachability checks (faster CI;
+catches only `unresolved_marker`).
+
+## Registry-only mode
+
+Add `--registry-only` to `ingest` to skip new-proof commissioning
+entirely. Useful for CI: if every `{{prove:}}` claim already has a
+registered proof, ingest runs offline and quickly. Misses are reported,
+not commissioned.

proof_engine_wiki-1.33.0/src/proof_engine_wiki.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+src/proof_engine_wiki/__init__.py
+src/proof_engine_wiki/cli.py
+src/proof_engine_wiki/ingest.py
+src/proof_engine_wiki/lint.py
+src/proof_engine_wiki/markers.py
+src/proof_engine_wiki.egg-info/PKG-INFO
+src/proof_engine_wiki.egg-info/SOURCES.txt
+src/proof_engine_wiki.egg-info/dependency_links.txt
+src/proof_engine_wiki.egg-info/entry_points.txt
+src/proof_engine_wiki.egg-info/requires.txt
+src/proof_engine_wiki.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_ingest.py
+tests/test_lint.py
+tests/test_markers.py

proof_engine_wiki-1.33.0/src/proof_engine_wiki.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

proof_engine_wiki-1.33.0/src/proof_engine_wiki.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+proof-engine-wiki = proof_engine_wiki.cli:main

proof_engine_wiki-1.33.0/src/proof_engine_wiki.egg-info/requires.txt

@@ -0,0 +1,3 @@
+proof-citations>=0.1
+proof-engine-registry>=0.1
+requests>=2.31

proof_engine_wiki-1.33.0/src/proof_engine_wiki.egg-info/top_level.txt

@@ -0,0 +1 @@
+proof_engine_wiki

proof_engine_wiki-1.33.0/tests/test_cli.py

@@ -0,0 +1,39 @@
+import json
+import subprocess
+import sys
+
+import pytest
+
+
+def test_cli_help():
+    r = subprocess.run(
+        [sys.executable, "-m", "proof_engine_wiki.cli", "--help"],
+        capture_output=True, text=True,
+    )
+    assert r.returncode == 0
+    assert "ingest" in r.stdout
+    assert "lint" in r.stdout
+
+
+def test_cli_lint_empty_dir(tmp_path):
+    r = subprocess.run(
+        [sys.executable, "-m", "proof_engine_wiki.cli", "lint", str(tmp_path), "--json"],
+        capture_output=True, text=True,
+    )
+    assert r.returncode == 0
+    payload = json.loads(r.stdout)
+    assert payload["findings"] == []
+
+
+def test_cli_lint_finds_unresolved_marker(tmp_path):
+    (tmp_path / "page.md").write_text("X {{prove: claim}} Y")
+    r = subprocess.run(
+        [sys.executable, "-m", "proof_engine_wiki.cli", "lint", str(tmp_path),
+         "--skip-network", "--json"],
+        capture_output=True, text=True,
+    )
+    # Findings present → exit code 1 (lint failed).
+    assert r.returncode == 1
+    payload = json.loads(r.stdout)
+    kinds = [f["kind"] for f in payload["findings"]]
+    assert "unresolved_marker" in kinds

proof_engine_wiki-1.33.0/tests/test_ingest.py

@@ -0,0 +1,88 @@
+import http.server
+import os
+import socketserver
+import threading
+from contextlib import contextmanager
+from pathlib import Path
+
+import pytest
+
+from proof_engine_registry.config import Registry
+from proof_engine_registry.emit import emit_registry_files
+
+from proof_engine_wiki.ingest import ingest_page, IngestResult
+
+
+REG_FIXTURES = Path(__file__).resolve().parents[2] / "proof-engine-registry" / "tests" / "fixtures" / "proofs"
+
+
+@contextmanager
+def _local_registry(tmp_path):
+    out = tmp_path / "registry"
+    emit_registry_files(
+        proofs_dir=REG_FIXTURES, output_dir=out,
+        base_url="http://127.0.0.1:0", registry_name="Test",
+    )
+    original = Path.cwd()
+    os.chdir(out)
+    try:
+        with socketserver.TCPServer(("127.0.0.1", 0),
+                                    http.server.SimpleHTTPRequestHandler) as httpd:
+            port = httpd.server_address[1]
+            t = threading.Thread(target=httpd.serve_forever, daemon=True)
+            t.start()
+            try:
+                yield [Registry(name="local", url=f"http://127.0.0.1:{port}")]
+            finally:
+                httpd.shutdown()
+    finally:
+        os.chdir(original)
+
+
+def test_ingest_registry_only_hits_use_existing_proof(tmp_path):
+    # Claim text must match the Phase 1b registry fixture's claim_natural
+    # exactly ("The sky is blue.") so the lookup is a guaranteed hit.
+    page = tmp_path / "claims.md"
+    page.write_text("The sky is {{prove: The sky is blue.}}.")
+
+    with _local_registry(tmp_path) as registries:
+        result = ingest_page(
+            page,
+            registries=registries,
+            registry_only=True,
+        )
+
+    assert isinstance(result, IngestResult)
+    assert len(result.markers) == 1
+    assert result.resolved_from_registry == 1
+    assert result.generated == 0
+    assert result.misses == 0
+    # Rewritten content should contain a link and an image (badge).
+    rewritten = page.read_text()
+    assert "](http://127.0.0.1" in rewritten  # link to registry proof URL
+    assert "badge.svg" in rewritten
+
+
+def test_ingest_registry_only_reports_misses(tmp_path):
+    page = tmp_path / "claims.md"
+    page.write_text("A claim: {{prove: definitely not in registry}}.")
+    with _local_registry(tmp_path) as registries:
+        result = ingest_page(
+            page, registries=registries, registry_only=True,
+        )
+    assert result.misses == 1
+    assert result.resolved_from_registry == 0
+    # Page is unchanged on miss in registry-only mode — the marker stays.
+    assert "{{prove: definitely not in registry}}" in page.read_text()
+
+
+def test_ingest_dry_run_does_not_write(tmp_path):
+    page = tmp_path / "claims.md"
+    page.write_text("X {{prove: The sky is blue.}} Y")
+    original = page.read_text()
+    with _local_registry(tmp_path) as registries:
+        result = ingest_page(
+            page, registries=registries, registry_only=True, dry_run=True,
+        )
+    assert result.resolved_from_registry == 1
+    assert page.read_text() == original  # untouched

proof_engine_wiki-1.33.0/tests/test_lint.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+
+import pytest
+
+from proof_engine_wiki.lint import lint_wiki, LintFinding
+
+
+def test_lint_reports_unresolved_markers(tmp_path):
+    p = tmp_path / "page.md"
+    p.write_text(
+        "Some claim {{prove: needs proof}} and another "
+        "{{prove: also needs proof}}."
+    )
+    findings = lint_wiki(tmp_path)
+    unresolved = [f for f in findings if f.kind == "unresolved_marker"]
+    assert len(unresolved) == 2
+
+
+def test_lint_reports_stale_proof_urls(tmp_path):
+    p = tmp_path / "page.md"
+    p.write_text(
+        "Statement [cited](https://proofengine.info/proofs/purchasing-power-decline/) "
+        "![proof](https://proofengine.info/proofs/purchasing-power-decline/badge.svg)."
+    )
+    # We don't actually fetch in this unit test — lint_wiki supports
+    # `skip_network=True` for test purposes.
+    findings = lint_wiki(tmp_path, skip_network=True)
+    # With skip_network=True, we don't issue stale findings, just confirm
+    # that the function completes and returns a list.
+    assert isinstance(findings, list)
+    assert all(isinstance(f, LintFinding) for f in findings)
+
+
+def test_lint_empty_dir_is_clean(tmp_path):
+    assert lint_wiki(tmp_path) == []

proof_engine_wiki-1.33.0/tests/test_markers.py

@@ -0,0 +1,90 @@
+from proof_engine_wiki.markers import (
+    Marker, find_markers, replace_markers,
+)
+
+
+def test_find_single_marker():
+    text = "The sky is {{prove: blue during the day}}."
+    markers = find_markers(text)
+    assert len(markers) == 1
+    assert markers[0].claim == "blue during the day"
+    # span = (start of `{{`, end-exclusive of `}}`)
+    # "The sky is " = 0..10 (11 chars), `{{prove: blue during the day}}` = 30 chars → (11, 41)
+    assert markers[0].span == (11, 41)
+
+
+def test_find_multiple_markers():
+    text = (
+        "Revenue grew {{prove: 10% YoY in 2024}}, and losses "
+        "narrowed {{prove: by 30% over the same period}}."
+    )
+    markers = find_markers(text)
+    assert len(markers) == 2
+    assert markers[0].claim == "10% YoY in 2024"
+    assert markers[1].claim == "by 30% over the same period"
+
+
+def test_marker_ignores_plain_braces():
+    text = "The set {a, b, c} is finite. {{not_a_marker}} leaves it alone."
+    assert find_markers(text) == []
+
+
+def test_marker_allows_leading_and_trailing_whitespace():
+    text = "{{prove:  the claim  }}"
+    m = find_markers(text)
+    assert m[0].claim == "the claim"
+
+
+def test_replace_markers_preserves_surrounding_text():
+    text = "X {{prove: A}} Y {{prove: B}} Z"
+    markers = find_markers(text)
+    replacements = {
+        markers[0].span: "[A](http://a)",
+        markers[1].span: "[B](http://b)",
+    }
+    rewritten = replace_markers(text, replacements)
+    assert rewritten == "X [A](http://a) Y [B](http://b) Z"
+
+
+def test_replace_markers_is_idempotent_on_unchanged_input():
+    text = "no markers here"
+    assert replace_markers(text, {}) == text
+
+
+def test_markers_inside_fenced_code_blocks_are_ignored():
+    text = (
+        "Real marker: {{prove: this one counts}}.\n"
+        "\n"
+        "```\n"
+        "Example syntax: {{prove: this is documentation}}\n"
+        "```\n"
+        "\n"
+        "And another real one: {{prove: also counts}}."
+    )
+    claims = [m.claim for m in find_markers(text)]
+    assert claims == ["this one counts", "also counts"]
+
+
+def test_markers_inside_inline_code_are_ignored():
+    text = "Use the `{{prove: x}}` syntax. Real: {{prove: real}}."
+    claims = [m.claim for m in find_markers(text)]
+    assert claims == ["real"]
+
+
+def test_markers_inside_html_comments_are_ignored():
+    text = "<!-- {{prove: hidden}} --> visible: {{prove: seen}}."
+    claims = [m.claim for m in find_markers(text)]
+    assert claims == ["seen"]
+
+
+def test_markers_inside_yaml_frontmatter_are_ignored():
+    text = (
+        "---\n"
+        "title: Example\n"
+        "note: '{{prove: metadata is not prose}}'\n"
+        "---\n"
+        "\n"
+        "Body: {{prove: body claim}}."
+    )
+    claims = [m.claim for m in find_markers(text)]
+    assert claims == ["body claim"]