@trac3er/oh-my-god 2.2.2 → 2.2.4

package/build/lib/runtime/artifact_parsers.py

@@ -1,161 +0,0 @@
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any
-from xml.etree import ElementTree
-
-
-def parse_junit(path: str) -> dict[str, Any]:
-    file_path = Path(path)
-    if not file_path.exists():
-        return {"valid": False, "summary": {}, "error": "file_not_found"}
-
-    try:
-        root = ElementTree.parse(file_path).getroot()
-    except (ElementTree.ParseError, OSError, ValueError) as exc:
-        return {"valid": False, "summary": {}, "error": f"junit_parse_error:{exc}"}
-
-    root_name = _local_name(root.tag)
-    if root_name not in {"testsuite", "testsuites"}:
-        return {
-            "valid": False,
-            "summary": {"root": root_name},
-            "error": "junit_invalid_root",
-        }
-
-    tests_value = root.attrib.get("tests", "")
-    return {
-        "valid": True,
-        "summary": {"root": root_name, "tests": str(tests_value).strip()},
-        "error": None,
-    }
-
-
-def parse_sarif(path: str) -> dict[str, Any]:
-    payload, error = _load_json(Path(path))
-    if error:
-        return {"valid": False, "summary": {}, "error": error}
-
-    runs = payload.get("runs") if isinstance(payload, dict) else None
-    if not isinstance(runs, list):
-        return {"valid": False, "summary": {}, "error": "sarif_missing_runs"}
-
-    return {
-        "valid": True,
-        "summary": {"runs": len(runs), "version": str(payload.get("version", "")).strip()},
-        "error": None,
-    }
-
-
-def parse_coverage(path: str) -> dict[str, Any]:
-    file_path = Path(path)
-    if not file_path.exists():
-        return {"valid": False, "summary": {}, "error": "file_not_found"}
-
-    xml_result = _parse_coverage_xml(file_path)
-    if xml_result["valid"]:
-        return xml_result
-
-    json_result = _parse_coverage_json(file_path)
-    if json_result["valid"]:
-        return json_result
-
-    return {
-        "valid": False,
-        "summary": {},
-        "error": xml_result.get("error") or json_result.get("error") or "coverage_missing_keys",
-    }
-
-
-def parse_browser_trace(path: str) -> dict[str, Any]:
-    payload, error = _load_json(Path(path))
-    if error:
-        return {"valid": False, "summary": {}, "error": error}
-
-    if not isinstance(payload, dict):
-        return {"valid": False, "summary": {}, "error": "browser_trace_invalid_payload"}
-
-    has_trace = "trace" in payload
-    has_events = isinstance(payload.get("events"), list)
-    if not (has_trace or has_events):
-        return {
-            "valid": False,
-            "summary": {},
-            "error": "browser_trace_missing_trace_or_events",
-        }
-
-    return {
-        "valid": True,
-        "summary": {"has_trace": has_trace, "event_count": len(payload.get("events", [])) if has_events else 0},
-        "error": None,
-    }
-
-
-def parse_diff_hunk(path: str) -> dict[str, Any]:
-    file_path = Path(path)
-    if not file_path.exists():
-        return {"valid": False, "summary": {}, "error": "file_not_found"}
-
-    try:
-        content = file_path.read_text(encoding="utf-8")
-    except (OSError, UnicodeDecodeError) as exc:
-        return {"valid": False, "summary": {}, "error": f"diff_read_error:{exc}"}
-
-    if "@@" not in content:
-        return {"valid": False, "summary": {}, "error": "diff_missing_hunk_marker"}
-
-    hunk_count = content.count("@@") // 2 if content.count("@@") >= 2 else 1
-    return {"valid": True, "summary": {"hunk_count": hunk_count}, "error": None}
-
-
-def _parse_coverage_xml(file_path: Path) -> dict[str, Any]:
-    try:
-        root = ElementTree.parse(file_path).getroot()
-    except (ElementTree.ParseError, OSError, ValueError):
-        return {"valid": False, "summary": {}, "error": "coverage_xml_parse_error"}
-
-    if "line-rate" in root.attrib:
-        return {
-            "valid": True,
-            "summary": {"line-rate": str(root.attrib.get("line-rate", "")).strip()},
-            "error": None,
-        }
-
-    return {"valid": False, "summary": {}, "error": "coverage_missing_line_rate"}
-
-
-def _parse_coverage_json(file_path: Path) -> dict[str, Any]:
-    payload, error = _load_json(file_path)
-    if error:
-        return {"valid": False, "summary": {}, "error": error}
-
-    if not isinstance(payload, dict):
-        return {"valid": False, "summary": {}, "error": "coverage_json_invalid_payload"}
-
-    if "coverage" not in payload:
-        return {"valid": False, "summary": {}, "error": "coverage_missing_coverage_key"}
-
-    return {
-        "valid": True,
-        "summary": {"coverage": payload.get("coverage")},
-        "error": None,
-    }
-
-
-def _load_json(file_path: Path) -> tuple[Any, str | None]:
-    if not file_path.exists():
-        return {}, "file_not_found"
-
-    try:
-        payload = json.loads(file_path.read_text(encoding="utf-8"))
-    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as exc:
-        return {}, f"json_parse_error:{exc}"
-
-    return payload, None
-
-
-def _local_name(tag: str) -> str:
-    if "}" not in tag:
-        return tag
-    return tag.rsplit("}", 1)[-1]

package/build/lib/runtime/asset_loader.py

@@ -1,62 +0,0 @@
-"""Helpers for locating packaged OMG assets from source checkouts or installs."""
-from __future__ import annotations
-
-from importlib import metadata
-from pathlib import Path
-
-
-_DIST_NAMES = ("oh-my-god", "oh_my_god")
-
-
-def project_root() -> Path:
-    return Path(__file__).resolve().parents[1]
-
-
-def resolve_asset(rel_path: str | Path) -> Path:
-    rel = Path(rel_path)
-    candidate = project_root() / rel
-    if candidate.exists():
-        return candidate
-
-    rel_posix = rel.as_posix()
-    for dist_name in _DIST_NAMES:
-        try:
-            dist = metadata.distribution(dist_name)
-        except metadata.PackageNotFoundError:
-            continue
-        for file in dist.files or []:
-            if str(file).endswith(rel_posix):
-                located = Path(dist.locate_file(file))
-                if located.exists():
-                    return located
-
-    raise FileNotFoundError(f"Unable to resolve packaged OMG asset: {rel_posix}")
-
-
-def resolve_assets(prefix: str | Path, suffix: str = "") -> list[Path]:
-    prefix_path = Path(prefix)
-    root_candidate = project_root() / prefix_path
-    if root_candidate.exists():
-        if root_candidate.is_dir():
-            if suffix:
-                return sorted(path for path in root_candidate.rglob("*") if path.is_file() and path.name.endswith(suffix))
-            return sorted(path for path in root_candidate.rglob("*") if path.is_file())
-        return [root_candidate]
-
-    prefix_posix = prefix_path.as_posix().rstrip("/")
-    matched: list[Path] = []
-    for dist_name in _DIST_NAMES:
-        try:
-            dist = metadata.distribution(dist_name)
-        except metadata.PackageNotFoundError:
-            continue
-        for file in dist.files or []:
-            file_text = str(file)
-            if not file_text.startswith(prefix_posix):
-                continue
-            if suffix and not file_text.endswith(suffix):
-                continue
-            located = Path(dist.locate_file(file))
-            if located.exists() and located.is_file():
-                matched.append(located)
-    return sorted(matched)

package/build/lib/runtime/background_verification.py

@@ -1,136 +0,0 @@
-from __future__ import annotations
-
-import json
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Callable
-
-BACKGROUND_VERIFICATION_REL_PATH = Path(".omg") / "state" / "background-verification.json"
-
-_VALID_STATUSES = frozenset({"running", "ok", "error", "blocked"})
-
-
-def publish_verification_state(
-    project_dir: str,
-    run_id: str,
-    status: str,
-    blockers: list[str],
-    evidence_links: list[str],
-    progress: dict[str, Any],
-) -> str:
-    state = {
-        "schema": "BackgroundVerificationState",
-        "schema_version": 2,
-        "run_id": run_id,
-        "status": status if status in _VALID_STATUSES else "error",
-        "blockers": blockers,
-        "evidence_links": evidence_links,
-        "progress": progress,
-        "updated_at": datetime.now(timezone.utc).isoformat(),
-    }
-
-    path = Path(project_dir) / BACKGROUND_VERIFICATION_REL_PATH
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps(state, indent=2, ensure_ascii=True), encoding="utf-8")
-    return str(path)
-
-
-def read_verification_state(project_dir: str, run_id: str | None = None) -> dict[str, Any] | None:
-    path = Path(project_dir) / BACKGROUND_VERIFICATION_REL_PATH
-    if not path.exists():
-        return None
-    try:
-        payload = json.loads(path.read_text(encoding="utf-8"))
-        if not isinstance(payload, dict):
-            return None
-        if payload.get("schema") != "BackgroundVerificationState":
-            return None
-        if int(payload.get("schema_version", 0)) != 2:
-            return None
-        status = str(payload.get("status", "")).strip()
-        if status not in _VALID_STATUSES:
-            return None
-        expected_run_id = str(run_id or "").strip()
-        if expected_run_id and str(payload.get("run_id", "")).strip() != expected_run_id:
-            return None
-        return payload
-    except (json.JSONDecodeError, OSError):
-        pass
-    return None
-
-
-# --- Task 10: Smart validation skipping + timeout gates ---
-
-# Profiles that must NEVER skip any validation stage.
-_NEVER_SKIP_PROFILES: frozenset[str] = frozenset({"release", "security-audit"})
-
-
-def should_skip_validation(evidence_profile: str | None, stage: str) -> bool:
-    """Return True if *stage* can be skipped for the given evidence profile.
-
-    Uses the central requirement registry from ``runtime.evidence_requirements``
-    so profile names and requirement lists are never hardcoded here.
-
-    Rules:
-    - ``release`` and ``security-audit`` profiles NEVER skip any stage.
-    - ``None``, empty, or unknown profiles fall back to FULL_REQUIREMENTS (no skip).
-    - For other profiles, a stage is skipped when it is NOT in that profile's
-      requirement list.
-    """
-    from runtime.evidence_requirements import requirements_for_profile
-
-    profile = (evidence_profile or "").strip()
-
-    # Never-skip profiles: full requirements, nothing skippable
-    if profile in _NEVER_SKIP_PROFILES:
-        return False
-
-    required = requirements_for_profile(profile if profile else None)
-    return stage not in required
-
-
-def skipped_stages_for_profile(evidence_profile: str | None) -> list[str]:
-    """Return the list of stages that WOULD be skipped for a given profile.
-
-    Useful for logging and HUD state.
-    """
-    from runtime.evidence_requirements import FULL_REQUIREMENTS
-
-    return [stage for stage in FULL_REQUIREMENTS if should_skip_validation(evidence_profile, stage)]
-
-
-def run_validation_with_timeout(
-    fn: Callable[[], str],
-    timeout_seconds: float = 60.0,
-) -> dict[str, Any]:
-    """Execute a validation callable with a timeout gate.
-
-    Returns a dict with ``status`` (the callable's return or ``"timeout"``)
-    and ``timed_out`` bool.  The callable must be a zero-arg function
-    returning a string status.
-    """
-    import concurrent.futures
-
-    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
-        future = pool.submit(fn)
-        try:
-            result = future.result(timeout=timeout_seconds)
-            return {"status": result, "timed_out": False}
-        except concurrent.futures.TimeoutError:
-            future.cancel()
-            return {"status": "timeout", "timed_out": True}
-
-
-def check_worker_stalls(project_dir: str) -> dict[str, Any]:
-    """Check for stalled workers via WorkerWatchdog; returns stall summary with run_ids."""
-    try:
-        from runtime.worker_watchdog import get_worker_watchdog
-        watchdog = get_worker_watchdog(project_dir)
-        stalled = watchdog.get_stalled_workers()
-        return {
-            "stalled_count": len(stalled),
-            "stalled_run_ids": [str(w.get("run_id", "")) for w in stalled],
-            "checked_at": datetime.now(timezone.utc).isoformat(),
-        }
-    except Exception:
-        return {"stalled_count": 0, "stalled_run_ids": [], "checked_at": datetime.now(timezone.utc).isoformat()}