proof-engine-wiki 1.33.0__py3-none-any.whl

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/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/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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,11 @@
+proof_engine_wiki/__init__.py,sha256=MZbvZcYrJAKKkCAS5EFzX8-qr_QTPjcuVb7T1YZcbbI,96
+proof_engine_wiki/cli.py,sha256=5hH6Riu7k9tFAeGr752MpF2nSPFsGODavQuXG45Ng4I,3168
+proof_engine_wiki/ingest.py,sha256=-s_aPZhPkvVWx1evZf3BFzPOGKhzMPikM51iC7Jll7I,4199
+proof_engine_wiki/lint.py,sha256=UtlhvzIXbGMCTGB7sB2c5_IuluyJkTybhtZXbrgu63E,2056
+proof_engine_wiki/markers.py,sha256=jEM0aEPKvoudsA7dBGowxcJ197Qdk6tzn8MIL_vPUDA,3363
+proof_engine_wiki-1.33.0.dist-info/licenses/LICENSE,sha256=zTTaGO6alQLutSENMjseDqP5xEDqs69DylIBhe2KsEE,1068
+proof_engine_wiki-1.33.0.dist-info/METADATA,sha256=H09i-yKN9-p-P32878joczOA9duhUgPzqq4vRl5piPs,3304
+proof_engine_wiki-1.33.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+proof_engine_wiki-1.33.0.dist-info/entry_points.txt,sha256=gRAOocT4ISwdYYQiCx5qaExzcmFjApfIbfOuEclwfck,65
+proof_engine_wiki-1.33.0.dist-info/top_level.txt,sha256=RiCV_bxWBQsfFbAbnFHYyd7uJbs4gj32OyPGqqxjHbY,18
+proof_engine_wiki-1.33.0.dist-info/RECORD,,

proof_engine_wiki-1.33.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

proof_engine_wiki-1.33.0.dist-info/entry_points.txt

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

proof_engine_wiki-1.33.0.dist-info/licenses/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.dist-info/top_level.txt

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