@hunter-harness/workflow-harness 0.2.32 → 0.2.34

package/harness/bundles/java/cursor/scripts/harness_report_model.py

@@ -0,0 +1,420 @@
+#!/usr/bin/env python3
+"""Normalized report facts shared by archive collection and rendering."""
+
+from __future__ import annotations
+
+import copy
+import datetime as dt
+from typing import Any, Iterable, Mapping
+
+REPORT_MODEL_SCHEMA_VERSION = 1
+UNKNOWN_VALUES = frozenset({"", "unknown", "not_available", "n/a", "null"})
+TERMINAL_STATUSES = frozenset(
+    {
+        "OK",
+        "PASS",
+        "PASSED",
+        "WARN",
+        "FAIL",
+        "FAILED",
+        "ERROR",
+        "BLOCKED",
+        "BLOCKED_BY_ENV",
+        "BLOCKED_BY_DBA",
+        "NOT_RUN",
+        "SKIPPED",
+        "USER_SKIPPED",
+        "NOT_APPLICABLE",
+        "CANCELLED",
+        "TIMED_OUT",
+        "TERMINATED",
+    }
+)
+IDENTITY_FIELDS = (
+    "repositoryId",
+    "changeName",
+    "baseCommit",
+    "productCommit",
+    "featureMergeHash",
+    "releaseTipHash",
+    "productTreeHash",
+    "environmentHash",
+    "candidateId",
+)
+CONTENT_HASH_FIELDS = frozenset({"productTreeHash", "environmentHash"})
+TARGET_IDENTITY_FIELDS = (
+    "target",
+    "repositoryId",
+    "changeName",
+    "productCommit",
+    "productTreeHash",
+    "environmentHash",
+    "profile",
+    "candidateId",
+)
+CURRENT_DISPOSITIONS = frozenset(
+    {"OPEN", "ACCEPTED_RISK", "DEFERRED", "UNKNOWN"}
+)
+
+
+def measurement(
+    value: Any = None,
+    *,
+    applicable: bool | None = True,
+    reason: str | None = None,
+) -> dict[str, Any]:
+    if isinstance(value, Mapping) and value.get("state") in {
+        "unknown",
+        "not_applicable",
+        "zero",
+        "known",
+    }:
+        return copy.deepcopy(dict(value))
+    if applicable is False:
+        result = {"state": "not_applicable", "value": None}
+    elif value is None or (
+        isinstance(value, str) and value.strip().lower() in UNKNOWN_VALUES
+    ):
+        result = {"state": "unknown", "value": None}
+    elif isinstance(value, (int, float)) and not isinstance(value, bool) and value == 0:
+        result = {"state": "zero", "value": value}
+    else:
+        result = {"state": "known", "value": copy.deepcopy(value)}
+    if reason:
+        result["reason"] = reason
+    return result
+
+
+def canonical_identity(summary: Mapping[str, Any]) -> dict[str, str]:
+    nested = summary.get("changeIdentity")
+    nested = nested if isinstance(nested, Mapping) else {}
+    fallbacks: dict[str, tuple[str, ...]] = {
+        "repositoryId": ("repositoryId",),
+        "changeName": ("changeName",),
+        "baseCommit": ("baseCommit",),
+        "productCommit": ("productCommit", "finalCommit"),
+        "featureMergeHash": ("featureMergeHash", "productCommit", "finalCommit"),
+        "releaseTipHash": ("releaseTipHash", "archiveCommit", "finalCommit"),
+        "productTreeHash": ("productTreeHash",),
+        "environmentHash": ("environmentHash",),
+        "candidateId": ("candidateId",),
+    }
+    identity: dict[str, str] = {}
+    for field in IDENTITY_FIELDS:
+        candidates = (nested.get(field),) + tuple(
+            summary.get(key) for key in fallbacks[field]
+        )
+        value = next(
+            (
+                str(candidate).strip()
+                for candidate in candidates
+                if candidate is not None and str(candidate).strip()
+            ),
+            "",
+        )
+        if field in CONTENT_HASH_FIELDS and value and value != "not_available":
+            value = "sha256:" + value.removeprefix("sha256:")
+        identity[field] = value
+    return identity
+
+
+def apply_identity_mirrors(
+    summary: Mapping[str, Any],
+    identity: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
+    result = copy.deepcopy(dict(summary))
+    canonical = dict(identity or canonical_identity(summary))
+    result["changeIdentity"] = copy.deepcopy(canonical)
+    for field in (
+        "productCommit",
+        "featureMergeHash",
+        "releaseTipHash",
+        "productTreeHash",
+        "environmentHash",
+    ):
+        if canonical.get(field):
+            result[field] = canonical[field]
+    git_facts = result.get("gitFacts")
+    git_facts = copy.deepcopy(git_facts) if isinstance(git_facts, Mapping) else {}
+    for field in (
+        "baseCommit",
+        "productCommit",
+        "featureMergeHash",
+        "releaseTipHash",
+        "productTreeHash",
+        "environmentHash",
+    ):
+        if canonical.get(field):
+            git_facts[field] = canonical[field]
+    result["gitFacts"] = git_facts
+    return result
+
+
+def _identity_value(field: str, value: Any) -> str:
+    text = str(value or "").strip()
+    if field in CONTENT_HASH_FIELDS and text and text != "not_available":
+        return text.removeprefix("sha256:")
+    return text
+
+
+def _record_time(record: Mapping[str, Any]) -> dt.datetime:
+    for field in ("finishedAt", "completedAt", "endedAt", "timestamp", "recordedAt"):
+        value = str(record.get(field) or "").strip()
+        if not value:
+            continue
+        try:
+            return dt.datetime.fromisoformat(value.replace("Z", "+00:00"))
+        except ValueError:
+            continue
+    return dt.datetime.min.replace(tzinfo=dt.timezone.utc)
+
+
+def select_latest_terminal_verification(
+    records: Iterable[Mapping[str, Any]],
+    target_identity: Mapping[str, Any],
+) -> dict[str, Any] | None:
+    matches: list[Mapping[str, Any]] = []
+    for record in records:
+        if str(record.get("status") or "").strip().upper() not in TERMINAL_STATUSES:
+            continue
+        matches_identity = True
+        for field in TARGET_IDENTITY_FIELDS:
+            expected = _identity_value(field, target_identity.get(field))
+            if not expected:
+                continue
+            actual = _identity_value(field, record.get(field))
+            if actual != expected:
+                matches_identity = False
+                break
+        if matches_identity:
+            matches.append(record)
+    if not matches:
+        return None
+    return copy.deepcopy(dict(max(matches, key=_record_time)))
+
+
+def current_findings(items: Iterable[Mapping[str, Any]]) -> list[dict[str, Any]]:
+    current: list[dict[str, Any]] = []
+    for item in items:
+        disposition = (
+            str(item.get("disposition") or "UNKNOWN")
+            .strip()
+            .upper()
+            .replace("-", "_")
+        )
+        if disposition not in CURRENT_DISPOSITIONS:
+            continue
+        entry = copy.deepcopy(dict(item))
+        entry["disposition"] = disposition
+        current.append(entry)
+    return current
+
+
+def latest_terminal_validations(
+    ledger: Mapping[str, Any] | None,
+) -> dict[str, dict[str, Any]]:
+    """Project validation history onto the current immutable product target."""
+    if not isinstance(ledger, Mapping):
+        return {}
+    raw_validations = ledger.get("validations")
+    raw_validations = (
+        raw_validations if isinstance(raw_validations, Mapping) else {}
+    )
+    global_history: list[Mapping[str, Any]] = []
+    dynamic_targets = ledger.get("verificationTargets")
+    if isinstance(dynamic_targets, Mapping):
+        for key, item in dynamic_targets.items():
+            if isinstance(item, Mapping):
+                global_history.append(
+                    {
+                        **dict(item),
+                        "target": (
+                            item.get("target")
+                            or item.get("verification")
+                            or str(key)
+                        ),
+                    }
+                )
+    elif isinstance(dynamic_targets, list):
+        global_history.extend(
+            item for item in dynamic_targets if isinstance(item, Mapping)
+        )
+    for key in ("verificationHistory", "validationHistory", "validationsHistory"):
+        items = ledger.get(key)
+        if isinstance(items, list):
+            global_history.extend(
+                item for item in items if isinstance(item, Mapping)
+            )
+    projected: dict[str, dict[str, Any]] = {}
+    targets = {
+        str(key) for key in raw_validations
+    } | {
+        str(item.get("target") or item.get("verification") or "")
+        for item in global_history
+        if item.get("target") or item.get("verification")
+    }
+    base_target = {
+        "repositoryId": ledger.get("repositoryId"),
+        "changeName": ledger.get("changeName"),
+        "productCommit": (
+            ledger.get("productCommit")
+            or ledger.get("headCommit")
+            or ledger.get("currentHead")
+        ),
+        "productTreeHash": ledger.get("productTreeHash"),
+        "environmentHash": ledger.get("environmentHash"),
+        "profile": ledger.get("profile"),
+        "candidateId": ledger.get("candidateId"),
+    }
+    for target in sorted(item for item in targets if item):
+        direct = raw_validations.get(target)
+        candidates: list[Mapping[str, Any]] = [
+            {
+                **dict(item),
+                "target": item.get("target") or item.get("verification") or target,
+            }
+            for item in global_history
+            if str(item.get("target") or item.get("verification") or "") == target
+        ]
+        if isinstance(direct, Mapping):
+            for key in ("history", "attempts"):
+                items = direct.get(key)
+                if isinstance(items, list):
+                    candidates.extend(
+                        {**dict(item), "target": target}
+                        for item in items
+                        if isinstance(item, Mapping)
+                    )
+            candidates.append({**dict(direct), "target": target})
+        selected = select_latest_terminal_verification(
+            candidates,
+            {"target": target, **base_target},
+        )
+        if selected is not None:
+            selected.pop("target", None)
+            projected[target] = selected
+        elif isinstance(direct, Mapping):
+            projected[target] = copy.deepcopy(dict(direct))
+    return projected
+
+
+def _measure_record(value: Any) -> Any:
+    if not isinstance(value, Mapping):
+        return measurement(value)
+    return {
+        str(key): _measure_record(item)
+        for key, item in value.items()
+    }
+
+
+def _mark_uncollected_metrics(
+    measured: dict[str, Any],
+    *paths: tuple[str, ...],
+) -> None:
+    for path in paths:
+        current: Any = measured
+        for key in path[:-1]:
+            if not isinstance(current, dict):
+                current = None
+                break
+            current = current.get(key)
+        if isinstance(current, dict) and path:
+            current[path[-1]] = measurement(
+                None,
+                reason="metric was not collected",
+            )
+
+
+def normalize_report(summary: Mapping[str, Any]) -> dict[str, Any]:
+    canonical = canonical_identity(summary)
+    review_items = summary.get("reviewFindings")
+    review_items = review_items if isinstance(review_items, list) else []
+    risks = current_findings(review_items)
+    remote_cost = summary.get("remoteCost")
+    remote_cost = remote_cost if isinstance(remote_cost, Mapping) else {}
+    artifact_storage = summary.get("artifactStorage")
+    artifact_storage = (
+        artifact_storage if isinstance(artifact_storage, Mapping) else {}
+    )
+    candidate = summary.get("candidateVerification")
+    candidate = copy.deepcopy(candidate) if isinstance(candidate, Mapping) else {}
+    current = {
+        "status": str(summary.get("finalStatus") or "UNKNOWN"),
+        "reasons": copy.deepcopy(list(summary.get("finalStatusReasons") or [])),
+        "stages": copy.deepcopy(dict(summary.get("stageStatus") or {})),
+        "findings": risks,
+        "knownRisks": (
+            copy.deepcopy(risks)
+            if review_items
+            else copy.deepcopy(list(summary.get("knownRisks") or []))
+        ),
+    }
+    history = {
+        "timeline": copy.deepcopy(list(summary.get("timeline") or [])),
+        "attempts": copy.deepcopy(
+            list((summary.get("timing") or {}).get("attempts") or [])
+            if isinstance(summary.get("timing"), Mapping)
+            else []
+        ),
+    }
+    release_raw = summary.get("releaseDecision")
+    release_raw = release_raw if isinstance(release_raw, Mapping) else {}
+    release_intent = str(summary.get("archiveIntent") or "")
+    release_decision = (
+        "NOT_REQUESTED"
+        if release_intent == "record-only"
+        else str(
+            release_raw.get("code")
+            or summary.get("releaseDecision")
+            or "NOT_DECIDED"
+        )
+    )
+    release = {
+        "decision": release_decision,
+        "eligible": (
+            False
+            if release_intent == "record-only"
+            else bool(
+                release_raw.get("releaseEligible")
+                if "releaseEligible" in release_raw
+                else summary.get("releaseEligible")
+            )
+        ),
+        "candidate": candidate,
+        "intent": release_intent,
+    }
+    remote_measurements = _measure_record(remote_cost)
+    if remote_cost.get("available") is False:
+        _mark_uncollected_metrics(
+            remote_measurements,
+            ("totals", "runCount"),
+            ("totals", "runnerMinutes"),
+            ("totals", "queueWaitMs"),
+            ("totals", "artifactBytes"),
+            ("totals", "duplicateRunCount"),
+        )
+    storage_measurements = _measure_record(artifact_storage)
+    if artifact_storage.get("available") is not True:
+        _mark_uncollected_metrics(
+            storage_measurements,
+            ("artifactCount",),
+            ("bytesAdded",),
+            ("bytesReused",),
+            ("bytesPruned",),
+        )
+    return {
+        "schemaVersion": REPORT_MODEL_SCHEMA_VERSION,
+        "changeName": str(summary.get("changeName") or ""),
+        "identity": canonical,
+        "outcomes": {
+            "current": current,
+            "history": history,
+            "release": release,
+        },
+        "verification": copy.deepcopy(dict(summary.get("verification") or {})),
+        "timing": copy.deepcopy(dict(summary.get("timing") or {})),
+        "measurements": {
+            "remoteCost": remote_measurements,
+            "artifactStorage": storage_measurements,
+        },
+    }

package/harness/bundles/java/cursor/scripts/harness_review.py

@@ -36,7 +36,15 @@ if hasattr(sys.stderr, "reconfigure"):
     sys.stderr.reconfigure(encoding="utf-8")
 
 SEVERITIES = {"RED", "YELLOW", "OK"}
-DISPOSITIONS = {"OPEN", "FIXED", "ACCEPTED_RISK", "DEFERRED", "UNKNOWN"}
+DISPOSITIONS = {
+    "OPEN",
+    "FIXED",
+    "ACCEPTED_RISK",
+    "DEFERRED",
+    "NOT_APPLICABLE",
+    "UNKNOWN",
+}
+CURRENT_RISK_DISPOSITIONS = {"OPEN", "ACCEPTED_RISK", "DEFERRED", "UNKNOWN"}
 FINDINGS_REL = Path("reports") / "review" / "review-findings.json"
 DISPOSITIONS_REL = Path("reports") / "review" / "fixback-dispositions.json"
 _REQUIRED_FINDING_FIELDS = ("dimension", "severity", "path", "line", "title")
@@ -253,6 +261,11 @@ def status(change_dir: Path) -> dict[str, Any]:
                 "disposition": disposition,
             }
         )
+    current_risks = [
+        item for item in items
+        if item.get("severity") in {"RED", "YELLOW"}
+        and item.get("disposition") in CURRENT_RISK_DISPOSITIONS
+    ]
     return {
         "ok": True,
         "code": "STATUS",
@@ -260,6 +273,8 @@ def status(change_dir: Path) -> dict[str, Any]:
         "counts": counts,
         "dispositions": disposition_counts,
         "items": items,
+        "currentRiskCount": len(current_risks),
+        "currentRisks": current_risks,
     }
 
 

package/harness/bundles/java/cursor/scripts/harness_verification.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""Select verification targets from a diff and dependency graph."""
+
+from __future__ import annotations
+
+import argparse
+import fnmatch
+import json
+from pathlib import Path
+from typing import Any
+
+
+def select_verifications(payload: dict[str, Any]) -> dict[str, Any]:
+    changed = sorted(
+        {
+            str(path).replace("\\", "/")
+            for path in payload.get("changedFiles", [])
+            if str(path).strip()
+        }
+    )
+    targets = [
+        target for target in payload.get("targets", []) if isinstance(target, dict)
+    ]
+    selected_ids: set[str] = set()
+    reasons: dict[str, list[str]] = {}
+    for target in targets:
+        target_id = str(target.get("id") or "")
+        patterns = [str(pattern) for pattern in target.get("inputs", [])]
+        matched = sorted(
+            path
+            for path in changed
+            if any(fnmatch.fnmatch(path, pattern) for pattern in patterns)
+        )
+        if matched:
+            selected_ids.add(target_id)
+            reasons[target_id] = ["input-match:" + path for path in matched]
+
+    changed_closure = True
+    while changed_closure:
+        changed_closure = False
+        for target in targets:
+            target_id = str(target.get("id") or "")
+            dependencies = {str(item) for item in target.get("dependsOn", [])}
+            if target_id not in selected_ids and dependencies & selected_ids:
+                selected_ids.add(target_id)
+                reasons[target_id] = [
+                    "consumer-of:" + dependency
+                    for dependency in sorted(dependencies & selected_ids)
+                ]
+                changed_closure = True
+
+    escalation_reasons: list[str] = []
+    lockfiles = {
+        "package-lock.json",
+        "npm-shrinkwrap.json",
+        "pnpm-lock.yaml",
+        "yarn.lock",
+        "pom.xml",
+        "Cargo.lock",
+        "go.sum",
+    }
+    if any(path in lockfiles or Path(path).name in lockfiles for path in changed):
+        escalation_reasons.append("lockfile-changed")
+    if any(
+        path.startswith(("packages/contracts/", "contracts/"))
+        or "/schema/" in path
+        or path.endswith((".schema.json", ".proto"))
+        for path in changed
+    ):
+        escalation_reasons.append("public-contract-changed")
+    selected = [
+        {**target, "selectionReasons": reasons[str(target.get("id") or "")]}
+        for target in targets
+        if str(target.get("id") or "") in selected_ids
+    ]
+    omitted = [
+        {**target, "omissionReason": "no impacted input or dependency"}
+        for target in targets
+        if str(target.get("id") or "") not in selected_ids
+    ]
+    return {
+        "ok": True,
+        "code": "VERIFICATION_TARGETS_SELECTED",
+        "changedFiles": changed,
+        "selected": selected,
+        "omitted": omitted,
+        "dependencyClosure": [str(item.get("id")) for item in selected],
+        "candidateRequired": bool(escalation_reasons),
+        "escalationReasons": escalation_reasons,
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="harness_verification.py")
+    parser.add_argument("select", nargs="?")
+    parser.add_argument("--input", required=True, type=Path)
+    parser.add_argument("--out", type=Path)
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv)
+    result = select_verifications(
+        json.loads(args.input.read_text(encoding="utf-8-sig"))
+    )
+    if args.out:
+        args.out.parent.mkdir(parents=True, exist_ok=True)
+        args.out.write_text(
+            json.dumps(result, ensure_ascii=False, indent=2) + "\n",
+            encoding="utf-8",
+        )
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())