@trac3er/oh-my-god 2.2.2 → 2.3.0

package/build/lib/runtime/merge_writer.py

@@ -1,320 +0,0 @@
-"""Merge-writer lock — single authorized writer for main-tree mutations.
-
-Enforces one-writer/many-readers semantics:
-- Read-only workers run concurrently without obtaining the merge lock.
-- Mutation-capable workers MUST hold the merge-writer lock AND run
-  inside a worktree before applying changes back to the main tree.
-
-Lock file:     .omg/state/merge-writer.lock   (JSON)
-Provenance:    .omg/evidence/merge-writer-<run_id>.json
-"""
-from __future__ import annotations
-
-import json
-import os
-from dataclasses import dataclass
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-from typing import cast
-
-
-# ---------------------------------------------------------------------------
-# Exceptions
-# ---------------------------------------------------------------------------
-
-class MergeWriterAuthorizationError(RuntimeError):
-    """Raised when an unauthorized worker attempts a main-tree mutation."""
-
-    def __init__(self, run_id: str, reason: str) -> None:
-        self.run_id = run_id
-        self.reason = reason
-        super().__init__(
-            f"merge-writer authorization denied for run_id={run_id}: {reason}"
-        )
-
-
-# ---------------------------------------------------------------------------
-# Token dataclass
-# ---------------------------------------------------------------------------
-
-@dataclass(frozen=True)
-class MergeWriterToken:
-    """Proof-of-ownership token returned by MergeWriter.acquire()."""
-
-    run_id: str
-    acquired_at: str
-    lock_path: str
-    provenance_path: str
-
-
-# ---------------------------------------------------------------------------
-# MergeWriter
-# ---------------------------------------------------------------------------
-
-def _now_iso() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def _write_atomic_json(path: Path, payload: dict[str, Any]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    tmp_path = path.with_name(f"{path.name}.tmp")
-    tmp_path.write_text(
-        json.dumps(payload, indent=2, ensure_ascii=True) + "\n",
-        encoding="utf-8",
-    )
-    os.replace(tmp_path, path)
-
-
-def _read_json(path: Path) -> dict[str, Any]:
-    if not path.exists():
-        return {}
-    try:
-        payload = json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return {}
-    return payload if isinstance(payload, dict) else {}
-
-
-class MergeWriter:
-    """Single merge-writer lock manager with provenance.
-
-    Usage::
-
-        mw = MergeWriter("/path/to/project")
-        token = mw.acquire("run-abc", reason="release merge")
-        # ... perform mutation ...
-        mw.release(token)
-    """
-
-    def __init__(self, project_dir: str | None = None) -> None:
-        if project_dir:
-            self.project_dir = Path(project_dir).resolve()
-        else:
-            self.project_dir = Path(
-                os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
-            ).resolve()
-
-    # --- Path helpers -------------------------------------------------------
-
-    def _lock_path(self) -> Path:
-        return self.project_dir / ".omg" / "state" / "merge-writer.lock"
-
-    def _provenance_path(self, run_id: str) -> Path:
-        return self.project_dir / ".omg" / "evidence" / f"merge-writer-{run_id}.json"
-
-    def _active_coordinator_run_id(self) -> str:
-        shadow_path = self.project_dir / ".omg" / "shadow" / "active-run"
-        if shadow_path.exists():
-            try:
-                shadow = shadow_path.read_text(encoding="utf-8").strip()
-            except OSError:
-                shadow = ""
-            if shadow:
-                return shadow
-
-        state_dir = self.project_dir / ".omg" / "state" / "release_run_coordinator"
-        if not state_dir.exists():
-            return ""
-        candidates = sorted(state_dir.glob("*.json"), key=lambda p: p.stat().st_mtime)
-        for path in reversed(candidates):
-            payload = _read_json(path)
-            if not payload:
-                continue
-            payload_dict = cast(dict[str, object], payload)
-            run_id = str(payload_dict.get("run_id", "")).strip()
-            if run_id:
-                return run_id
-        return ""
-
-    # --- Public API ---------------------------------------------------------
-
-    def acquire(self, run_id: str, reason: str = "") -> MergeWriterToken:
-        """Acquire the merge-writer lock.
-
-        Args:
-            run_id:  Unique identifier for the writer (typically a release run).
-            reason:  Human-readable reason for acquiring the lock.
-
-        Returns:
-            A ``MergeWriterToken`` proving ownership.
-
-        Raises:
-            MergeWriterAuthorizationError: If the lock is already held by
-                a different run_id.
-        """
-        lock_path = self._lock_path()
-        existing = _read_json(lock_path)
-
-        if existing:
-            existing_run_id = existing.get("run_id", "")
-            if existing_run_id and existing_run_id != run_id:
-                raise MergeWriterAuthorizationError(
-                    run_id,
-                    f"lock already held by run_id={existing_run_id}",
-                )
-
-        now = _now_iso()
-        lock_payload: dict[str, Any] = {
-            "run_id": run_id,
-            "acquired_at": now,
-            "reason": reason,
-            "pid": os.getpid(),
-        }
-        _write_atomic_json(lock_path, lock_payload)
-
-        provenance_path = self._provenance_path(run_id)
-        rel_lock = str(lock_path.relative_to(self.project_dir)).replace("\\", "/")
-        rel_prov = str(provenance_path.relative_to(self.project_dir)).replace("\\", "/")
-
-        return MergeWriterToken(
-            run_id=run_id,
-            acquired_at=now,
-            lock_path=rel_lock,
-            provenance_path=rel_prov,
-        )
-
-    def release(self, token: MergeWriterToken) -> dict[str, Any]:
-        """Release the merge-writer lock and write provenance.
-
-        Args:
-            token: The token returned by :meth:`acquire`.
-
-        Returns:
-            Provenance evidence dict written to disk.
-
-        Raises:
-            MergeWriterAuthorizationError: If the caller does not own the lock.
-        """
-        lock_path = self._lock_path()
-        existing = _read_json(lock_path)
-
-        if existing.get("run_id") != token.run_id:
-            raise MergeWriterAuthorizationError(
-                token.run_id,
-                "cannot release: lock is not held by this run_id",
-            )
-
-        provenance: dict[str, Any] = {
-            "schema": "MergeWriterProvenance",
-            "run_id": token.run_id,
-            "acquired_at": token.acquired_at,
-            "released_at": _now_iso(),
-            "lock_path": token.lock_path,
-            "provenance_path": token.provenance_path,
-            "pid": existing.get("pid"),
-            "reason": existing.get("reason", ""),
-        }
-
-        provenance_path = self._provenance_path(token.run_id)
-        _write_atomic_json(provenance_path, provenance)
-
-        # Remove lock file
-        try:
-            lock_path.unlink(missing_ok=True)
-        except OSError:
-            pass
-
-        return provenance
-
-    def is_locked(self) -> bool:
-        """Return True if the merge-writer lock is currently held."""
-        lock_path = self._lock_path()
-        if not lock_path.exists():
-            return False
-        existing = _read_json(lock_path)
-        return bool(existing.get("run_id"))
-
-    def get_current_owner(self) -> str | None:
-        """Return run_id of the current lock holder, or None."""
-        existing = _read_json(self._lock_path())
-        run_id = existing.get("run_id", "")
-        return run_id if run_id else None
-
-    def check_authorization_details(self, run_id: str) -> dict[str, Any]:
-        owner_run_id = self.get_current_owner() or ""
-        active_run_id = self._active_coordinator_run_id()
-        owner_matches = bool(owner_run_id) and owner_run_id == run_id
-        active_matches = (not active_run_id) or active_run_id == run_id
-        authorized = owner_matches and active_matches
-
-        reason = "authorized"
-        if not owner_run_id:
-            reason = "merge_writer_lock_missing"
-        elif owner_run_id != run_id:
-            reason = f"merge_writer_owner_mismatch:{owner_run_id}"
-        elif active_run_id and active_run_id != run_id:
-            reason = f"active_run_mismatch:{active_run_id}"
-
-        return {
-            "run_id": run_id,
-            "owner_run_id": owner_run_id,
-            "active_run_id": active_run_id,
-            "owner_matches": owner_matches,
-            "active_matches": active_matches,
-            "authorized": authorized,
-            "reason": reason,
-        }
-
-    def check_authorization(self, run_id: str) -> bool:
-        """Return True if *run_id* is the current authorized writer."""
-        return bool(self.check_authorization_details(run_id).get("authorized"))
-
-    # --- Governance helpers -------------------------------------------------
-
-    def require_authorization(
-        self,
-        run_id: str,
-        *,
-        mutation_type: str = "merge",
-        isolation: str = "none",
-    ) -> None:
-        """Gate a mutation attempt: block if unauthorized.
-
-        Mutation-capable workers MUST:
-        1. Run inside a worktree (isolation == "worktree").
-        2. Hold the merge-writer lock for their run_id.
-
-        Read-only workers (isolation != "worktree") are allowed through
-        without the lock.
-
-        Raises:
-            MergeWriterAuthorizationError: On unauthorized mutation.
-        """
-        normalized_isolation = str(isolation).strip().lower()
-
-        # Read-only workers never need the merge-writer lock
-        if normalized_isolation != "worktree":
-            return
-
-        if not self.is_locked():
-            raise MergeWriterAuthorizationError(
-                run_id,
-                f"mutation_type={mutation_type} requires merge-writer lock "
-                f"but no lock is held",
-            )
-
-        details = self.check_authorization_details(run_id)
-        if not details.get("authorized"):
-            owner = str(details.get("owner_run_id") or "unknown")
-            active = str(details.get("active_run_id") or "")
-            if active and active != run_id:
-                raise MergeWriterAuthorizationError(
-                    run_id,
-                    f"mutation_type={mutation_type} denied: active coordinator run_id="
-                    f"{active}, not {run_id}",
-                )
-            raise MergeWriterAuthorizationError(
-                run_id,
-                f"mutation_type={mutation_type} denied: lock held by "
-                f"run_id={owner}, not {run_id}",
-            )
-
-
-# ---------------------------------------------------------------------------
-# Module-level factory
-# ---------------------------------------------------------------------------
-
-def get_merge_writer(project_dir: str | None = None) -> MergeWriter:
-    """Factory for MergeWriter instances."""
-    return MergeWriter(project_dir)

package/build/lib/runtime/music_omr_testbed.py

@@ -1,333 +0,0 @@
-"""Music OMR + live transposition flagship testbed."""
-from __future__ import annotations
-
-import hashlib
-import json
-import time
-from datetime import datetime, timedelta, timezone
-from dataclasses import asdict, dataclass
-from pathlib import Path
-from typing import Any
-
-from runtime.release_run_coordinator import get_active_coordinator_run_id
-
-# --- deterministic transposition constants ---
-_CHROMATIC = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
-_KEY_SEMITONES: dict[str, int] = {n: i for i, n in enumerate(_CHROMATIC)}
-
-# Deterministic fixture registry — keeps OMR output repeatable without network.
-_DETERMINISTIC_FIXTURES: dict[str, dict[str, Any]] = {
-    "simple_c_major": {
-        "notes": ["C4", "D4", "E4", "F4", "G4", "A4", "B4", "C5"],
-        "time_signatures": ["4/4"],
-        "key_signatures": ["C"],
-        "measures": 2,
-    },
-    "simple_g_major": {
-        "notes": ["G4", "A4", "B4", "C5", "D5", "E5", "F#5", "G5"],
-        "time_signatures": ["4/4"],
-        "key_signatures": ["G"],
-        "measures": 2,
-    },
-    "chromatic_fragment": {
-        "notes": ["C4", "C#4", "D4", "D#4", "E4", "F4", "F#4", "G4"],
-        "time_signatures": ["4/4"],
-        "key_signatures": ["C"],
-        "measures": 2,
-    },
-    "waltz_three_four": {
-        "notes": ["C4", "E4", "G4", "C5", "E5", "G5"],
-        "time_signatures": ["3/4"],
-        "key_signatures": ["C"],
-        "measures": 2,
-    },
-}
-
-# Default inventory emitted when no explicit list is supplied.
-_DEFAULT_FIXTURE_INVENTORY: list[str] = [
-    "simple_c_major.json",
-    "simple_g_major.json",
-    "chromatic_fragment.json",
-    "waltz_three_four.json",
-    "transposition_pressure_fixture.json",
-]
-
-_MINIMUM_FIXTURE_COUNT = 5
-
-
-@dataclass
-class OMRResult:
-    notes: list[str]
-    time_signatures: list[str]
-    key_signatures: list[str]
-    measures: int
-    raw_output: str
-
-
-@dataclass
-class TranspositionResult:
-    original_key: str
-    target_key: str
-    transposed_notes: list[str]
-    verification_hash: str
-
-
-@dataclass
-class VerificationResult:
-    passed: bool
-    score: float
-    mismatches: list[str]
-    evidence_path: str
-
-
-class MusicOMRTestbed:
-    def __init__(self, project_dir: str) -> None:
-        self.project_dir = Path(project_dir)
-
-    def run_omr(self, score_fixture_path: str | Path) -> OMRResult:
-        """Runs OMR extraction on a deterministic fixture."""
-        path = Path(score_fixture_path)
-        if not path.exists():
-            raise FileNotFoundError(f"Fixture not found: {path}")
-
-        try:
-            data = json.loads(path.read_text(encoding="utf-8"))
-        except json.JSONDecodeError as e:
-            raise ValueError(f"Invalid JSON in fixture: {e}")
-
-        if "corrupted" in data.get("score_id", "") or data.get("metadata", {}).get("tempo", 0) < 0:
-            # Simulate a failure for corrupted scores
-            return OMRResult(
-                notes=[],
-                time_signatures=[],
-                key_signatures=[],
-                measures=0,
-                raw_output="error: corrupted score data",
-            )
-
-        # Deterministic fixture lookup
-        fixture_data = _DETERMINISTIC_FIXTURES.get(data.get("score_id"))
-        if fixture_data is not None:
-            return OMRResult(
-                notes=list(fixture_data["notes"]),
-                time_signatures=list(fixture_data["time_signatures"]),
-                key_signatures=list(fixture_data["key_signatures"]),
-                measures=fixture_data["measures"],
-                raw_output="raw_omr_data_here",
-            )
-
-        # Fallback for unknown fixtures
-        return OMRResult(
-            notes=[],
-            time_signatures=[],
-            key_signatures=[],
-            measures=0,
-            raw_output="unknown fixture",
-        )
-
-    @staticmethod
-    def _transpose_note(note: str, semitones: int) -> str:
-        """Transpose a single note by *semitones* (deterministic, no network)."""
-        if len(note) >= 3 and note[1] == "#":
-            name, octave = note[:2], int(note[2:])
-        else:
-            name, octave = note[:1], int(note[1:])
-        idx = _KEY_SEMITONES[name]
-        new_idx = idx + semitones
-        return f"{_CHROMATIC[new_idx % 12]}{octave + new_idx // 12}"
-
-    def run_transposition(self, omr_result: OMRResult, target_key: str) -> TranspositionResult:
-        """Transposes extracted score using deterministic interval arithmetic."""
-        if not omr_result.notes:
-            return TranspositionResult(
-                original_key=omr_result.key_signatures[0] if omr_result.key_signatures else "C",
-                target_key=target_key,
-                transposed_notes=[],
-                verification_hash="",
-            )
-
-        original_key = omr_result.key_signatures[0] if omr_result.key_signatures else "C"
-
-        # General-purpose deterministic transposition via semitone interval
-        interval = (_KEY_SEMITONES.get(target_key, 0) - _KEY_SEMITONES.get(original_key, 0)) % 12
-        transposed_notes = [self._transpose_note(n, interval) for n in omr_result.notes]
-
-        verification_hash = hashlib.sha256(json.dumps(transposed_notes).encode()).hexdigest()
-
-        return TranspositionResult(
-            original_key=original_key,
-            target_key=target_key,
-            transposed_notes=transposed_notes,
-            verification_hash=verification_hash,
-        )
-
-    def verify_result(self, result: Any, expected_fixture_path: str | Path) -> VerificationResult:
-        """Compares against expected output."""
-        path = Path(expected_fixture_path)
-        if not path.exists():
-            return VerificationResult(
-                passed=False,
-                score=0.0,
-                mismatches=[f"Expected fixture not found: {path}"],
-                evidence_path="",
-            )
-
-        try:
-            expected_data = json.loads(path.read_text(encoding="utf-8"))
-        except json.JSONDecodeError as e:
-            return VerificationResult(
-                passed=False,
-                score=0.0,
-                mismatches=[f"Invalid JSON in expected fixture: {e}"],
-                evidence_path="",
-            )
-
-        mismatches = []
-        
-        if isinstance(result, OMRResult):
-            if result.notes != expected_data.get("notes"):
-                mismatches.append(f"Notes mismatch: {result.notes} != {expected_data.get('notes')}")
-            if result.time_signatures != expected_data.get("time_signatures"):
-                mismatches.append(f"Time signatures mismatch: {result.time_signatures} != {expected_data.get('time_signatures')}")
-            if result.key_signatures != expected_data.get("key_signatures"):
-                mismatches.append(f"Key signatures mismatch: {result.key_signatures} != {expected_data.get('key_signatures')}")
-            if result.measures != expected_data.get("measures"):
-                mismatches.append(f"Measures mismatch: {result.measures} != {expected_data.get('measures')}")
-        elif isinstance(result, TranspositionResult):
-            if result.original_key != expected_data.get("original_key"):
-                mismatches.append(f"Original key mismatch: {result.original_key} != {expected_data.get('original_key')}")
-            if result.target_key != expected_data.get("target_key"):
-                mismatches.append(f"Target key mismatch: {result.target_key} != {expected_data.get('target_key')}")
-            if result.transposed_notes != expected_data.get("transposed_notes"):
-                mismatches.append(f"Transposed notes mismatch: {result.transposed_notes} != {expected_data.get('transposed_notes')}")
-        else:
-            mismatches.append(f"Unknown result type: {type(result)}")
-
-        passed = len(mismatches) == 0
-        score = 1.0 if passed else 0.0
-
-        return VerificationResult(
-            passed=passed,
-            score=score,
-            mismatches=mismatches,
-            evidence_path="",
-        )
-
-    def run_pressure_suite(
-        self,
-        omr_result: OMRResult,
-        target_key: str,
-        *,
-        iterations: int,
-        runtime_ceiling_seconds: float,
-    ) -> dict[str, Any]:
-        """Run N transpositions and validate determinism + runtime ceiling.
-
-        Returns a structured result with hashes, elapsed time, and a
-        determinism flag suitable for chaos replay evidence.
-        """
-        hashes: list[str] = []
-        started = time.perf_counter()
-        for _ in range(iterations):
-            result = self.run_transposition(omr_result, target_key)
-            hashes.append(result.verification_hash)
-        elapsed = time.perf_counter() - started
-
-        unique_hashes = set(hashes)
-        deterministic = len(unique_hashes) == 1
-
-        return {
-            "deterministic": deterministic,
-            "unique_hash": next(iter(unique_hashes)) if deterministic else None,
-            "hash_count": len(unique_hashes),
-            "iterations": iterations,
-            "elapsed_seconds": elapsed,
-            "within_ceiling": elapsed < runtime_ceiling_seconds,
-            "runtime_ceiling_seconds": runtime_ceiling_seconds,
-        }
-
-    def _resolve_run_id(self, requested_run_id: str) -> str:
-        run_id = requested_run_id.strip()
-        if run_id:
-            return run_id
-        active_run_id = get_active_coordinator_run_id(str(self.project_dir))
-        if active_run_id:
-            return active_run_id
-        raise ValueError("run_id required: no active coordinator run found")
-
-    @staticmethod
-    def _is_fresh(generated_at: str, max_age_seconds: float) -> bool:
-        if max_age_seconds <= 0:
-            return False
-        try:
-            generated = datetime.fromisoformat(generated_at.replace("Z", "+00:00"))
-        except ValueError:
-            return False
-        now = datetime.now(timezone.utc)
-        if generated.tzinfo is None:
-            generated = generated.replace(tzinfo=timezone.utc)
-        return (now - generated).total_seconds() <= max_age_seconds
-
-    def emit_evidence(
-        self,
-        run_id: str,
-        results: dict[str, Any],
-        *,
-        trace_id: str = "",
-        fixture_inventory: list[str] | None = None,
-        freshness_max_age_seconds: float = 86_400,
-    ) -> str:
-        """Writes evidence to .omg/evidence/music-omr-<run_id>.json."""
-        evidence_dir = self.project_dir / ".omg" / "evidence"
-        evidence_dir.mkdir(parents=True, exist_ok=True)
-        resolved_run_id = self._resolve_run_id(run_id)
-
-        evidence_path = evidence_dir / f"music-omr-{resolved_run_id}.json"
-
-        generated_at = datetime.now(timezone.utc)
-        expires_at = generated_at + timedelta(seconds=freshness_max_age_seconds)
-        if fixture_inventory is None:
-            fixture_inventory = list(_DEFAULT_FIXTURE_INVENTORY)
-        deduped_inventory = list(dict.fromkeys(fixture_inventory))
-        inventory_valid = len(deduped_inventory) >= _MINIMUM_FIXTURE_COUNT
-
-        payload: dict[str, Any] = {
-            "schema": "MusicOMREvidence",
-            "schema_version": "2.1.0",
-            "run_id": resolved_run_id,
-            "trace_id": trace_id,
-            "trace": {
-                "trace_id": trace_id,
-                "gate": "music-omr-daily",
-                "run_scope": "release-run",
-            },
-            "trace_metadata": {
-                "testbed": "MusicOMRTestbed",
-                "fixture_count": len(deduped_inventory),
-                "fixture_inventory_valid": inventory_valid,
-                "deterministic": True,
-                "gate": "music-omr-daily",
-                "run_id_linkage": resolved_run_id,
-            },
-            "fixture_inventory": deduped_inventory,
-            "fixture_count": len(deduped_inventory),
-            "fixture_inventory_valid": inventory_valid,
-            "freshness": {
-                "generated_at": generated_at.isoformat(),
-                "expires_at": expires_at.isoformat(),
-                "max_age_seconds": freshness_max_age_seconds,
-                "freshness_threshold_secs": freshness_max_age_seconds,
-                "is_fresh": self._is_fresh(generated_at.isoformat(), freshness_max_age_seconds),
-            },
-            "freshness_threshold_secs": freshness_max_age_seconds,
-            "results": {},
-        }
-
-        for key, value in results.items():
-            if hasattr(value, "__dataclass_fields__"):
-                payload["results"][key] = asdict(value)
-            else:
-                payload["results"][key] = value
-
-        evidence_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
-        return str(evidence_path)