@trac3er/oh-my-god 2.2.2 → 2.2.4

package/build/lib/runtime/mutation_gate.py

@@ -1,215 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-import re
-import warnings
-from datetime import datetime, timezone
-from hashlib import sha256
-from pathlib import Path
-
-from runtime.release_run_coordinator import get_active_coordinator_run_id, resolve_current_run_id
-from runtime.test_intent_lock import verify_done_when, verify_lock
-from runtime.tool_plan_gate import has_tool_plan_for_run
-
-
-_MUTATING_TOOLS = frozenset({"Write", "Edit", "MultiEdit"})
-_EXEMPTIONS = frozenset({"docs", "config", "generated", "test"})
-_MUTATION_BASH_PATTERNS = (
-    r"\b(git\s+(add|commit|push|rebase|cherry-pick|merge|tag))\b",
-    r"\b(rm|mv|cp|tee|touch|mkdir|rmdir|ln)\b",
-    r"\b(sed\s+-i|perl\s+-pi)\b",
-    r"\b(chmod|chown)\b",
-)
-_HARMLESS_REDIRECTION_PATTERNS = (
-    re.compile(r"(?:^|[\s;&|()])\d*>>?\s*/dev/(?:null|stdout|stderr)(?=\s|$)"),
-    re.compile(r"(?:^|[\s;&|()])\d*>&\d+(?=\s|$)"),
-    re.compile(r"(?:^|[\s;&|()])\d*>&-(?=\s|$)"),
-)
-_FILE_WRITE_REDIRECTION_PATTERN = re.compile(
-    r"(?:^|[\s;&|()])\d*>>?(?!\s*(?:/dev/(?:null|stdout|stderr)\b|&\d+\b|&-\b))\s*\S+"
-)
-
-
-def check_mutation_allowed(
-    tool: str,
-    file_path: str,
-    project_dir: str,
-    lock_id: str | None,
-    *,
-    exemption: str | None = None,
-    command: str | None = None,
-    run_id: str | None = None,
-    metadata: dict[str, object] | None = None,
-) -> dict[str, str | None]:
-    normalized_tool = str(tool or "").strip()
-    normalized_file_path = str(file_path or "").strip()
-    normalized_lock_id = str(lock_id or "").strip() or None
-    normalized_exemption = str(exemption or "").strip().lower() or None
-    normalized_command = str(command or "").strip()
-    metadata_obj = metadata if isinstance(metadata, dict) else {}
-    explicit_exempt = bool(metadata_obj.get("exempt") is True)
-    strict_mode = os.environ.get("OMG_TDD_GATE_STRICT", "1").strip() != "0"
-
-    if explicit_exempt and (normalized_exemption in _EXEMPTIONS or metadata_obj.get("exempt_reason")):
-        return {
-            "status": "exempt",
-            "reason": "metadata exemption allows mutation without lock",
-            "lock_id": normalized_lock_id,
-        }
-
-    if normalized_exemption in _EXEMPTIONS:
-        return {
-            "status": "exempt",
-            "reason": f"exemption '{normalized_exemption}' allows mutation without lock",
-            "lock_id": normalized_lock_id,
-        }
-
-    requires_lock = normalized_tool in _MUTATING_TOOLS
-    if normalized_tool == "Bash":
-        requires_lock = _is_mutation_capable_bash(normalized_command)
-
-    if not requires_lock:
-        return {
-            "status": "allowed",
-            "reason": "tool is read-only for mutation gate",
-            "lock_id": normalized_lock_id,
-        }
-
-    resolved_run_id = (
-        get_active_coordinator_run_id(project_dir=project_dir)
-        or str(run_id or "").strip()
-        or resolve_current_run_id(project_dir=project_dir)
-    )
-
-    verification = verify_lock(project_dir, run_id=resolved_run_id, lock_id=normalized_lock_id)
-    if verification.get("status") != "ok":
-        reason = str(verification.get("reason", "no_active_test_intent_lock"))
-        if strict_mode:
-            _write_block_artifact(project_dir, normalized_tool, normalized_file_path, reason)
-            return {
-                "status": "blocked",
-                "reason": reason,
-                "lock_id": normalized_lock_id,
-            }
-
-        _write_warning_artifact(project_dir, normalized_tool, normalized_file_path, reason)
-        warnings.warn(
-            f"mutation_gate_permissive_allow:{normalized_tool}:{reason}",
-            RuntimeWarning,
-            stacklevel=2,
-        )
-        return {
-            "status": "allowed",
-            "reason": reason,
-            "lock_id": normalized_lock_id,
-        }
-
-    if resolved_run_id and not has_tool_plan_for_run(project_dir, resolved_run_id):
-        reason = "tool_plan_required"
-        if strict_mode:
-            _write_block_artifact(project_dir, normalized_tool, normalized_file_path, reason)
-            return {
-                "status": "blocked",
-                "reason": reason,
-                "lock_id": normalized_lock_id,
-            }
-        _write_warning_artifact(project_dir, normalized_tool, normalized_file_path, reason)
-        warnings.warn(
-            f"mutation_gate_permissive_allow:{normalized_tool}:{reason}",
-            RuntimeWarning,
-            stacklevel=2,
-        )
-        return {
-            "status": "allowed",
-            "reason": reason,
-            "lock_id": normalized_lock_id,
-        }
-
-    if resolved_run_id:
-        done_when_verification = verify_done_when(metadata_obj, run_id=resolved_run_id)
-        if done_when_verification.get("status") != "ok":
-            reason = str(done_when_verification.get("reason", "done_when_required"))
-            if strict_mode:
-                _write_block_artifact(project_dir, normalized_tool, normalized_file_path, reason)
-                return {
-                    "status": "blocked",
-                    "reason": reason,
-                    "lock_id": normalized_lock_id,
-                }
-
-            _write_warning_artifact(project_dir, normalized_tool, normalized_file_path, reason)
-            warnings.warn(
-                f"mutation_gate_permissive_allow:{normalized_tool}:{reason}",
-                RuntimeWarning,
-                stacklevel=2,
-            )
-            return {
-                "status": "allowed",
-                "reason": reason,
-                "lock_id": normalized_lock_id,
-            }
-
-    return {
-        "status": "allowed",
-        "reason": "active test intent lock found",
-        "lock_id": str(verification.get("lock_id") or normalized_lock_id or "") or None,
-    }
-
-
-def _is_mutation_capable_bash(command: str) -> bool:
-    normalized_command = str(command or "").strip()
-    if not normalized_command:
-        return False
-    lowered = _strip_harmless_redirections(normalized_command.lower())
-    for pattern in _MUTATION_BASH_PATTERNS:
-        if re.search(pattern, lowered):
-            return True
-    if _FILE_WRITE_REDIRECTION_PATTERN.search(lowered):
-        return True
-    return False
-
-
-def _strip_harmless_redirections(command: str) -> str:
-    sanitized = command
-    for pattern in _HARMLESS_REDIRECTION_PATTERNS:
-        sanitized = pattern.sub(" ", sanitized)
-    return re.sub(r"\s+", " ", sanitized).strip()
-
-
-def _write_warning_artifact(project_dir: str, tool: str, file_path: str, reason: str) -> None:
-    state_dir = Path(project_dir) / ".omg" / "state" / "mutation_gate"
-    state_dir.mkdir(parents=True, exist_ok=True)
-
-    path_hash = sha256(file_path.encode("utf-8")).hexdigest()[:8]
-    artifact_path = state_dir / f"warn-{path_hash}.json"
-    payload = {
-        "status": "warning",
-        "tool": tool,
-        "file_path": file_path,
-        "reason": reason,
-        "ts": datetime.now(timezone.utc).isoformat(),
-    }
-
-    temp_path = artifact_path.with_suffix(".tmp")
-    temp_path.write_text(json.dumps(payload, sort_keys=True, indent=2), encoding="utf-8")
-    os.replace(temp_path, artifact_path)
-
-
-def _write_block_artifact(project_dir: str, tool: str, file_path: str, reason: str) -> None:
-    state_dir = Path(project_dir) / ".omg" / "state" / "mutation_gate"
-    state_dir.mkdir(parents=True, exist_ok=True)
-
-    path_hash = sha256(file_path.encode("utf-8")).hexdigest()[:8]
-    artifact_path = state_dir / f"{path_hash}.json"
-    payload = {
-        "status": "blocked",
-        "tool": tool,
-        "file_path": file_path,
-        "reason": reason,
-        "ts": datetime.now(timezone.utc).isoformat(),
-    }
-
-    temp_path = artifact_path.with_suffix(".tmp")
-    temp_path.write_text(json.dumps(payload, sort_keys=True, indent=2), encoding="utf-8")
-    os.replace(temp_path, artifact_path)

package/build/lib/runtime/omc_compat.py

@@ -1,7 +0,0 @@
-"""Backward-compatible aliases for legacy compatibility routing.
-
-Primary implementation lives in `runtime.compat`.
-"""
-from __future__ import annotations
-
-from .compat import *  # noqa: F401,F403

package/build/lib/runtime/omg_browser_cli.py

@@ -1,95 +0,0 @@
-"""OMG wrapper around the upstream Playwright CLI."""
-from __future__ import annotations
-
-import shutil
-from pathlib import Path
-from typing import Any, Callable
-
-from runtime.playwright_pack import PlaywrightPack
-
-WhichFn = Callable[[str], str | None]
-RunnerFn = Callable[..., dict[str, object]]
-
-PLAYWRIGHT_REMEDIATION = (
-    "Install Playwright CLI with `npx playwright` support or `npm install -g @playwright/cli@latest`, "
-    "then install browsers and optional skills."
-)
-
-
-def resolve_playwright_command(*, which: WhichFn = shutil.which) -> list[str] | None:
-    """Resolve the preferred upstream Playwright CLI command."""
-    if which("playwright"):
-        return ["playwright"]
-    if which("playwright-cli"):
-        return ["playwright-cli"]
-    if which("npx"):
-        return ["npx", "playwright"]
-    return None
-
-
-def ensure_playwright_cli(
-    *,
-    project_dir: str | Path,
-    which: WhichFn = shutil.which,
-) -> dict[str, Any]:
-    """Report whether an upstream Playwright CLI is available."""
-    command = resolve_playwright_command(which=which)
-    project_root = str(Path(project_dir).resolve())
-    if command is None:
-        return {
-            "status": "missing",
-            "project_dir": project_root,
-            "remediation": PLAYWRIGHT_REMEDIATION,
-        }
-    return {
-        "status": "ready",
-        "project_dir": project_root,
-        "command": command,
-    }
-
-
-def run_browser_cli(
-    *,
-    goal: str,
-    project_dir: str | Path,
-    runner: RunnerFn,
-    which: WhichFn = shutil.which,
-    isolated: bool = False,
-    output_dir: str | Path | None = None,
-) -> dict[str, Any]:
-    """Run the resolved Playwright CLI and normalize its artifacts into OMG evidence."""
-    readiness = ensure_playwright_cli(project_dir=project_dir, which=which)
-    if readiness["status"] != "ready":
-        return readiness
-
-    project_root = Path(project_dir).resolve()
-    result = runner(
-        command=list(readiness["command"]),
-        cwd=str(project_root),
-        goal=goal,
-    )
-    if int(result.get("returncode", 1)) != 0:
-        return {
-            "status": "error",
-            "project_dir": str(project_root),
-            "command": readiness["command"],
-            "goal": goal,
-            "stdout": str(result.get("stdout", "")),
-            "stderr": str(result.get("stderr", "")),
-        }
-
-    pack = PlaywrightPack(project_dir=project_root, isolated=isolated)
-    normalized = pack.ingest_external_artifacts(
-        output_dir=output_dir or (project_root / ".omg" / "evidence" / "browser"),
-        trace_path=result.get("trace_path"),
-        junit_path=result.get("junit_path"),
-        screenshots=result.get("screenshots"),
-        metadata=dict(result.get("metadata") or {}),
-    )
-    return {
-        "status": "success",
-        "project_dir": str(project_root),
-        "command": readiness["command"],
-        "goal": goal,
-        **normalized,
-    }