@trac3er/oh-my-god 2.2.3 → 2.2.5

package/runtime/evidence_narrator.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import TypedDict
+
+from runtime.verdict_schema import VerdictReceipt
+
+
+class NarrativeResult(TypedDict):
+    verdict_summary: str
+    blockers_section: list[str]
+    provenance_note: str | None
+    evidence_paths_section: list[str]
+    next_actions: list[str]
+
+
+def narrate(verdict: VerdictReceipt) -> NarrativeResult:
+    status = verdict.get("status", "pending")
+    
+    if status == "pass":
+        summary = "The verification process passed successfully."
+    elif status == "fail":
+        summary = "The verification process failed."
+    elif status == "action_required":
+        summary = "Action required to complete the verification process."
+    else:
+        summary = "The verification process is pending or in an unknown state."
+
+    blockers = list(verdict.get("blockers", []))
+    next_steps = list(verdict.get("next_steps", []))
+    
+    evidence_paths = verdict.get("evidence_paths", {})
+    evidence_sections = [f"{k}: {v}" for k, v in evidence_paths.items()]
+    
+    provenance = verdict.get("provenance")
+    
+    return {
+        "verdict_summary": summary,
+        "blockers_section": blockers,
+        "provenance_note": provenance,
+        "evidence_paths_section": evidence_sections,
+        "next_actions": next_steps,
+    }

package/runtime/github_review_bot.py

@@ -5,9 +5,67 @@ from typing import Any
 
 import requests
 
+from runtime.evidence_narrator import narrate
 from runtime.github_integration import get_github_token
 from runtime.github_review_contract import GitHubReviewContract, ReviewStatus
 from runtime.github_review_formatter import format_review_payload
+from runtime.verdict_schema import VerdictReceipt, VerdictStatus
+
+CHECK_RUN_NAME = "OMG PR Reviewer"
+
+_VERDICT_TO_CONCLUSION: dict[VerdictStatus, str] = {
+    "pass": "success",
+    "fail": "failure",
+    "action_required": "action_required",
+    "pending": "neutral",
+}
+
+
+def _annotations_from_blockers(blockers: list[str]) -> list[dict[str, Any]]:
+    return [
+        {
+            "path": ".omg/evidence",
+            "start_line": 1,
+            "end_line": 1,
+            "annotation_level": "failure",
+            "message": blocker,
+        }
+        for blocker in blockers
+        if blocker
+    ]
+
+
+def build_check_run_payload(
+    verdict_receipt: VerdictReceipt,
+    *,
+    annotations: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    status: VerdictStatus = verdict_receipt.get("status", "pending")
+    conclusion = _VERDICT_TO_CONCLUSION.get(status, "neutral")
+
+    narrative = narrate(verdict_receipt)
+    summary = narrative["verdict_summary"]
+    blockers = list(verdict_receipt.get("blockers", []))
+
+    resolved_annotations: list[dict[str, Any]]
+    if annotations is not None:
+        resolved_annotations = list(annotations)
+    elif blockers:
+        resolved_annotations = _annotations_from_blockers(blockers)
+    else:
+        resolved_annotations = []
+
+    return {
+        "name": CHECK_RUN_NAME,
+        "status": "completed",
+        "conclusion": conclusion,
+        "output": {
+            "title": f"{CHECK_RUN_NAME} verdict",
+            "summary": summary[:65000],
+            "annotations": resolved_annotations,
+        },
+        "actions": [],
+    }
 
 
 class GitHubReviewBot:
@@ -71,15 +129,19 @@ class GitHubReviewBot:
         if review_result.get("status") != "ok":
             return review_result
 
+        check_annotations = self._build_annotations_from_inline(
+            list(formatted.get("inline_comments", []))
+        )
         check_result = self._post_check_run(
             repo=repo,
             token=token,
             head_sha=head_sha,
             review_status=str(formatted["review_status"]),
             body=str(formatted["body"]),
+            annotations=check_annotations,
         )
-        if check_result.get("status") != "ok":
-            return check_result
+        # Check-run is supplementary — don't fail the whole flow if it errors
+        # (e.g., app may lack Checks permission while still having PR write)
 
         review_status = self._to_review_status(str(formatted["review_status"]))
         state = self.contract.record_review(
@@ -160,6 +222,25 @@ class GitHubReviewBot:
         }
         return self._post(url=url, payload=payload, expected_field="id", error_code="GITHUB_REVIEW_POST_FAILED", headers=headers)
 
+    def _build_annotations_from_inline(
+        self, inline_comments: list[dict[str, object]]
+    ) -> list[dict[str, Any]]:
+        annotations: list[dict[str, Any]] = []
+        for comment in inline_comments:
+            path = str(comment.get("path", "")).strip()
+            body = str(comment.get("body", "")).strip()
+            line = comment.get("line")
+            if not path or not body or not isinstance(line, int):
+                continue
+            annotations.append({
+                "path": path,
+                "start_line": line,
+                "end_line": line,
+                "annotation_level": "warning",
+                "message": body,
+            })
+        return annotations
+
     def _post_check_run(
         self,
         *,
@@ -168,6 +249,7 @@ class GitHubReviewBot:
         head_sha: str,
         review_status: str,
         body: str,
+        annotations: list[dict[str, Any]] | None = None,
     ) -> dict[str, object]:
         url = f"{self.api_base}/repos/{repo}/check-runs"
         conclusion = {
@@ -175,14 +257,16 @@ class GitHubReviewBot:
             "rejected": "failure",
             "pending": "neutral",
         }.get(review_status, "neutral")
-        payload = {
-            "name": "OMG PR Reviewer",
+        resolved_annotations = list(annotations) if annotations else []
+        payload: dict[str, Any] = {
+            "name": CHECK_RUN_NAME,
             "head_sha": head_sha,
             "status": "completed",
             "conclusion": conclusion,
             "output": {
-                "title": "OMG PR Reviewer verdict",
+                "title": f"{CHECK_RUN_NAME} verdict",
                 "summary": body[:65000],
+                "annotations": resolved_annotations,
             },
         }
         headers = self._headers(token)
@@ -287,4 +371,4 @@ class GitHubReviewBot:
         }
 
 
-__all__ = ["GitHubReviewBot"]
+__all__ = ["GitHubReviewBot", "build_check_run_payload"]

package/runtime/github_review_formatter.py

@@ -1,7 +1,15 @@
 from __future__ import annotations
 
+from importlib import import_module
 from typing import Any
 
+from runtime.evidence_narrator import narrate
+
+
+def _normalize_verdict_payload(payload: dict[str, Any]) -> dict[str, Any]:
+    module = import_module("runtime.verdict_schema")
+    return dict(module.normalize_verdict(payload))
+
 
 def format_review_payload(evidence: dict[str, Any], *, inline_batch_limit: int = 20) -> dict[str, Any]:
     if not isinstance(evidence, dict):
@@ -19,14 +27,13 @@ def format_review_payload(evidence: dict[str, Any], *, inline_batch_limit: int =
             "message": "Review evidence is missing required artifacts.",
         }
 
-    raw_verdict = str(evidence.get("verdict", evidence.get("status", "pending"))).strip().lower()
+    normalized_verdict = _normalize_verdict_payload(evidence)
+    narrative = narrate(normalized_verdict)
+    raw_verdict = normalized_verdict["status"]
     review_status = _normalize_review_status(raw_verdict)
     review_event = _review_event_for_status(review_status)
 
     checks = _normalize_checks(evidence.get("checks"))
-    evidence_gaps = _as_str_list(evidence.get("evidence_gaps"))
-    if not evidence_gaps:
-        evidence_gaps = _as_str_list(evidence.get("unresolved_risks"))
 
     raw_inline = evidence.get("inline_comments")
     inline_comments = _normalize_inline_comments(raw_inline)
@@ -39,10 +46,23 @@ def format_review_payload(evidence: dict[str, Any], *, inline_batch_limit: int =
         raw_verdict=raw_verdict,
         artifacts=artifacts,
         checks=checks,
-        evidence_gaps=evidence_gaps,
+        narrative=narrative,
         dropped_comments=dropped_comments,
     )
 
+    changed_files = _as_str_list(evidence.get("changed_files"))
+    categories = _as_str_list(evidence.get("categories"))
+    goal = str(evidence.get("goal", "")).strip()
+    pr_risk: dict[str, Any] = {}
+    if changed_files or categories:
+        from runtime.delta_classifier import compute_pr_risk_payload
+        pr_risk = compute_pr_risk_payload(
+            changed_files=changed_files,
+            categories=categories,
+            goal=goal,
+            evidence=evidence,
+        )
+
     return {
         "status": "ok",
         "review_status": review_status,
@@ -50,6 +70,7 @@ def format_review_payload(evidence: dict[str, Any], *, inline_batch_limit: int =
         "body": body,
         "inline_comments": selected_comments,
         "dropped_inline_comments": dropped_comments,
+        "pr_risk": pr_risk,
     }
 
 
@@ -59,7 +80,7 @@ def _build_review_body(
     raw_verdict: str,
     artifacts: list[str],
     checks: list[dict[str, str]],
-    evidence_gaps: list[str],
+    narrative: dict[str, Any],
     dropped_comments: int,
 ) -> str:
     lines: list[str] = [
@@ -68,6 +89,9 @@ def _build_review_body(
         f"- CI verdict: **{raw_verdict or review_status}**",
         f"- Review state: **{review_status}**",
         "",
+        f"### Summary",
+        narrative["verdict_summary"],
+        "",
         "### Evidence Artifacts",
     ]
     for artifact in artifacts:
@@ -86,12 +110,20 @@ def _build_review_body(
 
     lines.append("")
     lines.append("### Evidence Gaps")
+    evidence_gaps = narrative["blockers_section"]
     if evidence_gaps:
         for gap in evidence_gaps:
             lines.append(f"- {gap}")
     else:
         lines.append("- None reported.")
 
+    next_actions = narrative["next_actions"]
+    if next_actions:
+        lines.append("")
+        lines.append("### Next Actions")
+        for action in next_actions:
+            lines.append(f"- {action}")
+
     if dropped_comments > 0:
         lines.append("")
         lines.append(f"- Inline comments truncated to API-safe batch size; omitted: {dropped_comments}")