stagemesh 0.6.0__py3-none-any.whl

stagemesh/__init__.py

@@ -0,0 +1,7 @@
+"""StageMesh vNext."""
+
+from .hands_off_recovery import apply_provider_no_progress_recovery_patch
+
+__version__ = "0.6.0"
+
+apply_provider_no_progress_recovery_patch()

stagemesh/_build_info.py

@@ -0,0 +1,3 @@
+SOURCE_COMMIT = 'a89f9461be3e6f339a39c950effadb9022f45f03'
+SOURCE_DIRTY = False
+BUILT_FROM = '/home/runner/work/stagemesh/stagemesh'

stagemesh/acceptance.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .security import WorkspaceBoundary
+
+
+@dataclass(frozen=True)
+class AcceptanceCheck:
+    name: str
+    status: str
+    output: str
+
+
+class AcceptanceValidationError(ValueError):
+    pass
+
+
+def run_check(name: str, command: list[str], cwd: Path) -> AcceptanceCheck:
+    name = _validate_text(name, "acceptance check name")
+    command = _validate_command(command)
+    cwd = _validate_root(cwd)
+    result = subprocess.run(command, cwd=cwd, text=True, capture_output=True, check=False)
+    status = "PASS" if result.returncode == 0 else "FAIL"
+    return AcceptanceCheck(name, status, result.stdout + result.stderr)
+
+
+def local_acceptance_report(root: Path, include_acceptance: bool = True) -> dict[str, object]:
+    root = _validate_root(root)
+    checks = [
+        run_check("compile", [sys.executable, "-m", "compileall", "-q", "src", "scripts", "build_backend.py"], root),
+        run_check("invariants", [sys.executable, "scripts/invariants.py"], root),
+        run_check("provider_acceptance", [sys.executable, "scripts/provider_acceptance.py"], root),
+        run_check("github_acceptance", [sys.executable, "scripts/github_acceptance.py"], root),
+        run_check("live_acceptance", [sys.executable, "scripts/live_acceptance.py", "--json"], root),
+        run_check("clean_acceptance", [sys.executable, "scripts/clean_acceptance.py"], root),
+        run_check("install", [sys.executable, "-m", "pip", "install", ".", "--target", ".tmp-install", "--no-cache-dir", "--upgrade"], root),
+    ]
+    if include_acceptance:
+        checks.insert(2, run_check("acceptance", [sys.executable, "scripts/acceptance.py"], root))
+    gaps = proof_gaps(checks)
+    return {
+        "generated_at": time.time(),
+        "status": "PASS" if all(check.status == "PASS" for check in checks) else "FAIL",
+        "proof_status": "BLOCKED_ON_EXTERNAL_EVIDENCE" if gaps else "PROVEN",
+        "proof_gaps": gaps,
+        "checks": [
+            {"name": check.name, "status": check.status, "output": check.output[-4000:]}
+            for check in checks
+        ],
+    }
+
+
+def write_acceptance_report(root: Path, output: Path, include_acceptance: bool = True) -> None:
+    root = _validate_root(root)
+    output = WorkspaceBoundary(root).require_inside(output)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(
+        json.dumps(local_acceptance_report(root, include_acceptance), indent=2, sort_keys=True),
+        encoding="utf-8",
+    )
+
+
+def proof_gaps(checks: list[AcceptanceCheck]) -> list[dict[str, str]]:
+    gaps: list[dict[str, str]] = []
+    for check in checks:
+        parsed = _structured_proof_gaps(check)
+        if parsed:
+            gaps.extend(parsed)
+            continue
+        for line in check.output.splitlines():
+            if "NOT_CONFIGURED" in line or "NOT_PROVEN" in line:
+                gaps.append({"check": check.name, "evidence": line.strip()})
+    return gaps
+
+
+def _structured_proof_gaps(check: AcceptanceCheck) -> list[dict[str, str]]:
+    try:
+        data = json.loads(check.output)
+    except json.JSONDecodeError:
+        return []
+    if not isinstance(data, dict) or not isinstance(data.get("checks"), list):
+        return []
+    gaps: list[dict[str, str]] = []
+    for item in data["checks"]:
+        if not isinstance(item, dict):
+            continue
+        name = item.get("name")
+        status = item.get("status")
+        if isinstance(name, str) and status in {"NOT_CONFIGURED", "NOT_PROVEN"}:
+            gaps.append({"check": check.name, "evidence": f"{name}: {status}"})
+    return gaps
+
+
+def _validate_text(value: str, field: str, max_length: int = 200) -> str:
+    if not isinstance(value, str):
+        raise AcceptanceValidationError(f"{field} must be a string")
+    normalized = value.strip()
+    if not normalized:
+        raise AcceptanceValidationError(f"{field} must be a non-empty string")
+    if len(normalized) > max_length:
+        raise AcceptanceValidationError(f"{field} must be {max_length} characters or fewer")
+    return normalized
+
+
+def _validate_command(command: list[str]) -> list[str]:
+    if not isinstance(command, list) or not command:
+        raise AcceptanceValidationError("acceptance command must be a non-empty list")
+    return [_validate_text(arg, "acceptance command argument", 1000) for arg in command]
+
+
+def _validate_root(root: Path) -> Path:
+    resolved = Path(root).resolve()
+    if not resolved.exists() or not resolved.is_dir():
+        raise AcceptanceValidationError("acceptance root must be an existing directory")
+    return resolved

stagemesh/acceptance_matrix.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+from .completion_audit import completion_audit
+from .persistence import Store
+from .security import WorkspaceBoundary
+
+
+class AcceptanceMatrixValidationError(ValueError):
+    pass
+
+
+@dataclass(frozen=True)
+class MatrixRow:
+    area: str
+    status: str
+    evidence: str
+
+
+def acceptance_matrix(store: Store | None = None, candidate_sha: str | None = None) -> dict[str, object]:
+    audit = completion_audit(store, candidate_sha)
+    rows = [
+        MatrixRow(str(item["requirement"]), str(item["status"]), str(item["evidence"]))
+        for item in audit["items"]
+    ]
+    proven = sum(1 for row in rows if row.status == "PROVEN")
+    return {
+        "status": "COMPLETE" if proven == len(rows) else "INCOMPLETE",
+        "proven": proven,
+        "total": len(rows),
+        "rows": [row.__dict__ for row in rows],
+    }
+
+
+def write_acceptance_matrix(
+    path: Path, store: Store | None = None, root: Path | None = None, candidate_sha: str | None = None
+) -> None:
+    path = _validate_output(path, root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(acceptance_matrix(store, candidate_sha), indent=2, sort_keys=True), encoding="utf-8")
+
+
+def _validate_output(path: Path, root: Path | None) -> Path:
+    output = Path(path).resolve()
+    if root is not None:
+        return WorkspaceBoundary(Path(root).resolve()).require_inside(output)
+    if not output.name or output.is_dir():
+        raise AcceptanceMatrixValidationError("acceptance matrix output must name a file")
+    return output