@trac3er/oh-my-god 2.2.3 → 2.2.5

package/build/lib/hooks/compression_feedback.py

@@ -1,254 +0,0 @@
-#!/usr/bin/env python3
-"""PostToolUseFailure Hook — Acon-style compression feedback loop."""
-
-from __future__ import annotations
-
-import json
-import os
-import re
-import shutil
-import sys
-from datetime import datetime, timedelta, timezone
-from typing import Any
-
-HOOKS_DIR = os.path.dirname(__file__)
-PROJECT_ROOT = os.path.dirname(HOOKS_DIR)
-if HOOKS_DIR not in sys.path:
-    sys.path.insert(0, HOOKS_DIR)
-if PROJECT_ROOT not in sys.path:
-    sys.path.insert(0, PROJECT_ROOT)
-
-from hooks._common import atomic_json_write, get_feature_flag, get_project_dir, json_input, setup_crash_handler
-
-
-setup_crash_handler("compression-feedback", fail_closed=False)
-
-MAX_BYTES = 5 * 1024 * 1024
-PROMOTION_THRESHOLD = 3
-POST_COMPACTION_WINDOW = timedelta(minutes=30)
-
-
-def _parse_iso8601(value: str | None) -> datetime | None:
-    if not value or not isinstance(value, str):
-        return None
-    try:
-        return datetime.fromisoformat(value.replace("Z", "+00:00")).astimezone(timezone.utc)
-    except Exception:
-        return None
-
-
-def _extract_failure_reason(payload: dict[str, Any]) -> str:
-    for key in ("error", "message", "failure_reason"):
-        val = payload.get(key)
-        if isinstance(val, str) and val.strip():
-            return val.strip()
-
-    tool_response = payload.get("tool_response")
-    if isinstance(tool_response, dict):
-        for key in ("error", "message", "stderr", "stdout"):
-            val = tool_response.get(key)
-            if isinstance(val, str) and val.strip():
-                return val.strip()[:500]
-    elif isinstance(tool_response, str) and tool_response.strip():
-        return tool_response.strip()[:500]
-
-    return "unknown"
-
-
-def _read_json(path: str) -> dict[str, Any] | None:
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            data = json.load(f)
-            if isinstance(data, dict):
-                return data
-    except Exception:
-        pass
-    return None
-
-
-def _read_last_compaction_ts(state_dir: str) -> datetime | None:
-    data = _read_json(os.path.join(state_dir, "last-compaction.json"))
-    if not data:
-        return None
-    for key in ("timestamp", "ts", "compacted_at", "last_compaction"):
-        parsed = _parse_iso8601(data.get(key))
-        if parsed:
-            return parsed
-    return None
-
-
-def _read_handoff_snapshot(state_dir: str) -> str:
-    handoff_path = os.path.join(state_dir, "handoff.md")
-    try:
-        with open(handoff_path, "r", encoding="utf-8", errors="ignore") as f:
-            return f.read()[:4000]
-    except Exception:
-        return ""
-
-
-def _candidate_items(context_snapshot: str) -> list[str]:
-    items: list[str] = []
-    for raw_line in context_snapshot.splitlines():
-        line = raw_line.strip()
-        if not line:
-            continue
-        line = re.sub(r"^[-*]\s+", "", line)
-        line = re.sub(r"^\d+\.\s+", "", line)
-        if line and not line.startswith("#"):
-            items.append(line)
-    return items
-
-
-def _match_dropped_items(payload: dict[str, Any], context_snapshot: str) -> list[str]:
-    if not context_snapshot:
-        return []
-    haystack = " ".join(
-        [
-            json.dumps(payload.get("tool_input", ""), sort_keys=True),
-            json.dumps(payload.get("tool_response", ""), sort_keys=True),
-            str(payload.get("error", "")),
-            str(payload.get("message", "")),
-        ]
-    ).lower()
-
-    matched = []
-    for item in _candidate_items(context_snapshot):
-        token = item.strip().lower()
-        if token and token in haystack:
-            matched.append(item)
-    return sorted(set(matched))
-
-
-def _rotate_jsonl_if_needed(path: str) -> None:
-    try:
-        if os.path.exists(path) and os.path.getsize(path) > MAX_BYTES:
-            archive = path + ".1"
-            if os.path.exists(archive):
-                try:
-                    os.remove(archive)
-                except OSError:
-                    pass
-            shutil.move(path, archive)
-    except Exception:
-        pass
-
-
-def _read_feedback_entries(path: str) -> list[dict[str, Any]]:
-    rows: list[dict[str, Any]] = []
-    if not os.path.exists(path):
-        return rows
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            for line in f:
-                line = line.strip()
-                if not line:
-                    continue
-                try:
-                    row = json.loads(line)
-                    if isinstance(row, dict):
-                        rows.append(row)
-                except Exception:
-                    continue
-    except Exception:
-        pass
-    return rows
-
-
-def _append_jsonl(path: str, entry: dict[str, Any]) -> None:
-    try:
-        import fcntl
-
-        fd = open(path, "a", encoding="utf-8")
-        fcntl.flock(fd.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
-        fd.write(json.dumps(entry, separators=(",", ":")) + "\n")
-        fcntl.flock(fd.fileno(), fcntl.LOCK_UN)
-        fd.close()
-    except (ImportError, BlockingIOError):
-        try:
-            with open(path, "a", encoding="utf-8") as f:
-                f.write(json.dumps(entry, separators=(",", ":")) + "\n")
-        except Exception:
-            pass
-    except Exception:
-        pass
-
-
-def _promotions(entries: list[dict[str, Any]], matched_items: list[str]) -> list[str]:
-    promoted: list[str] = []
-    for item in matched_items:
-        count = 0
-        for row in entries:
-            row_items = row.get("matched_items", [])
-            if isinstance(row_items, list) and item in row_items:
-                count += 1
-        if count >= PROMOTION_THRESHOLD:
-            promoted.append(item)
-    return sorted(set(promoted))
-
-
-def _update_always_keep(state_dir: str, promoted_items: list[str]) -> None:
-    if not promoted_items:
-        return
-    path = os.path.join(state_dir, "always-keep.json")
-    current = _read_json(path) or {}
-    existing = current.get("items", [])
-    if not isinstance(existing, list):
-        existing = []
-    merged = sorted(set(str(x) for x in existing if x) | set(promoted_items))
-    atomic_json_write(path, {"items": merged})
-
-
-def main() -> None:
-    data = json_input()
-
-    if not get_feature_flag("CONTEXT_MANAGER", default=False):
-        sys.exit(0)
-
-    project_dir = get_project_dir()
-    state_dir = os.path.join(project_dir, ".omg", "state")
-    os.makedirs(state_dir, exist_ok=True)
-
-    compaction_ts = _read_last_compaction_ts(state_dir)
-    failure_ts = _parse_iso8601(data.get("timestamp")) or datetime.now(timezone.utc)
-    if not compaction_ts:
-        sys.exit(0)
-
-    delta = failure_ts - compaction_ts
-    post_compaction = timedelta(0) <= delta <= POST_COMPACTION_WINDOW
-    if not post_compaction:
-        sys.exit(0)
-
-    feedback_path = os.path.join(state_dir, "compression-feedback.jsonl")
-    context_snapshot = _read_handoff_snapshot(state_dir)
-    matched_items = _match_dropped_items(data, context_snapshot)
-
-    _rotate_jsonl_if_needed(feedback_path)
-    prior_entries = _read_feedback_entries(feedback_path)
-
-    provisional_entry = {
-        "ts": datetime.now(timezone.utc).isoformat(),
-        "session_id": str(data.get("session_id", "")),
-        "tool_name": str(data.get("tool_name", "")),
-        "failure_reason": _extract_failure_reason(data),
-        "post_compaction": True,
-        "context_snapshot": context_snapshot,
-        "promoted_items": [],
-        "matched_items": matched_items,
-    }
-
-    all_entries = prior_entries + [provisional_entry]
-    promoted_items = _promotions(all_entries, matched_items)
-    provisional_entry["promoted_items"] = promoted_items
-
-    _append_jsonl(feedback_path, provisional_entry)
-    _update_always_keep(state_dir, promoted_items)
-
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except Exception:
-        pass
-    sys.exit(0)

package/build/lib/hooks/config-guard.py

@@ -1,216 +0,0 @@
-#!/usr/bin/env python3
-"""ConfigChange Hook: Settings Tamper Detection + Trust Review
-
-Monitors Claude settings changes and writes Trust Review artifacts to
-.omg/trust/manifest.lock.json.
-"""
-import contextlib
-import json
-import os
-import sys
-
-HOOKS_DIR = os.path.dirname(__file__)
-if HOOKS_DIR not in sys.path:
-    sys.path.insert(0, HOOKS_DIR)
-
-from _common import setup_crash_handler, json_input, _resolve_project_dir
-
-try:
-    from _common import is_bypass_mode
-except ImportError:  # pragma: no cover - compatibility with older runtimes
-    def is_bypass_mode(_payload):
-        return False
-
-
-try:
-    from _common import is_bypass_all
-except ImportError:  # pragma: no cover - compatibility with older runtimes
-    def is_bypass_all(_payload):
-        return False
-
-# Compatibility marker for existing tests and policy docs.
-DANGEROUS_IN_ALLOW = [
-    "Bash(rm:*)", "Bash(sudo:*)", "Bash(curl:*)", "Bash(wget:*)",
-    "Bash(ssh:*)", "Bash(nc:*)", "Bash(ncat:*)",
-]
-
-setup_crash_handler("config-guard", fail_closed=False)
-
-try:
-    from trust_review import review_config_change, write_trust_manifest, format_review_summary
-except Exception as e:
-    print(f"[OMG] config-guard: trust_review import failed: {type(e).__name__}: {e}", file=sys.stderr)
-    sys.exit(0)
-
-data = json_input()
-
-def _decode_json_object(value):
-    if isinstance(value, dict):
-        return value
-    if isinstance(value, str):
-        raw = value.strip()
-        if not raw:
-            return None
-        try:
-            parsed = json.loads(raw)
-        except Exception:  # intentional: decode fallback
-            return None
-        return parsed if isinstance(parsed, dict) else None
-    return None
-
-
-def _extract_config_path(payload):
-    file_path = payload.get("file_path")
-    if isinstance(file_path, str) and file_path.strip():
-        return file_path
-
-    tool_input = payload.get("tool_input", {})
-    if isinstance(tool_input, dict):
-        legacy_path = tool_input.get("file_path")
-        if isinstance(legacy_path, str) and legacy_path.strip():
-            return legacy_path
-    return ""
-
-
-def _extract_config_object(payload, keys):
-    for key in keys:
-        parsed = _decode_json_object(payload.get(key))
-        if parsed is not None:
-            return parsed
-
-    tool_input = payload.get("tool_input", {})
-    if isinstance(tool_input, dict):
-        for key in keys:
-            parsed = _decode_json_object(tool_input.get(key))
-            if parsed is not None:
-                return parsed
-    return None
-
-
-def _is_watched_settings_path(path):
-    normalized = path.replace("\\", "/").rstrip("/")
-    return normalized == "settings.json" or normalized.endswith("/settings.json")
-
-
-def _is_setup_in_progress():
-    """Check if setup wizard is in progress by reading settings.json."""
-    try:
-        project_dir = _resolve_project_dir()
-        settings_path = os.path.join(project_dir, "settings.json")
-        if not os.path.exists(settings_path):
-            return False
-        with open(settings_path, "r", encoding="utf-8") as f:
-            settings = json.load(f)
-            if isinstance(settings, dict):
-                omg_config = settings.get("_omg", {})
-                if isinstance(omg_config, dict):
-                    return omg_config.get("setup_in_progress", False)
-    except Exception:
-        pass
-    return False
-
-
-def _is_mcp_config_file(path):
-    """Check if the file being changed is .mcp.json."""
-    normalized = path.replace("\\", "/").rstrip("/")
-    return normalized == ".mcp.json" or normalized.endswith("/.mcp.json")
-
-
-def _is_watched_config_path(path):
-    return _is_watched_settings_path(path) or _is_mcp_config_file(path)
-
-
-def _snapshot_path_for(project_dir, config_path):
-    snapshot_dir = os.path.join(project_dir, ".omg", "trust")
-    os.makedirs(snapshot_dir, exist_ok=True)
-    filename = "last-mcp.json" if _is_mcp_config_file(config_path) else "last-settings.json"
-    return os.path.join(snapshot_dir, filename)
-
-
-config_path = _extract_config_path(data)
-if not config_path:
-    sys.exit(0)
-
-if not _is_watched_config_path(config_path):
-    sys.exit(0)
-
-project_dir = _resolve_project_dir()
-new_path = config_path if os.path.isabs(config_path) else os.path.join(project_dir, config_path)
-if not os.path.exists(new_path):
-    sys.exit(0)
-
-try:
-    with open(new_path, "r", encoding="utf-8") as f:
-        new_config = json.load(f)
-        if not isinstance(new_config, dict):
-            sys.exit(0)
-except Exception as e:
-    print(f"[OMG] config-guard: config read failed: {type(e).__name__}: {e}", file=sys.stderr)
-    sys.exit(0)
-
-# Load previous config snapshot for diff-based trust review.
-snapshot_path = _snapshot_path_for(project_dir, config_path)
-
-old_config = {}
-# Prefer explicit old config in payload if present.
-payload_old = _extract_config_object(
-    data,
-    ("old_config", "old_settings", "old_content", "before", "old_value"),
-)
-if isinstance(payload_old, dict):
-    old_config = payload_old
-elif os.path.exists(snapshot_path):
-    try:
-        with open(snapshot_path, "r", encoding="utf-8") as f:
-            old_config = json.load(f)
-            if not isinstance(old_config, dict):
-                old_config = {}
-    except Exception as e:
-        print(f"[OMG] config-guard: snapshot read failed: {type(e).__name__}: {e}", file=sys.stderr)
-        old_config = {}
-
-# Prefer explicit new config when the payload provides it.
-payload_new = _extract_config_object(
-    data,
-    ("new_config", "new_settings", "new_content", "after", "new_value"),
-)
-if isinstance(payload_new, dict):
-    new_config = payload_new
-
-# Exemption: skip trust_review for .mcp.json changes during setup wizard
-if _is_setup_in_progress() and _is_mcp_config_file(config_path):
-    sys.exit(0)
-
-# In bypass mode, skip trust_review asks (but not denials for critical issues)
-if is_bypass_mode(data) or is_bypass_all(data):
-    sys.exit(0)
-
-review = review_config_change(config_path, old_config, new_config)
-write_trust_manifest(project_dir, review)
-
-# Keep a rolling snapshot for next review.
-with contextlib.suppress(OSError):  # intentional: cleanup
-    with open(snapshot_path, "w", encoding="utf-8") as f:
-        json.dump(new_config, f, indent=2, ensure_ascii=True)
-
-# Backward-compatibility variable expected by tests.
-hooks = new_config.get("hooks", {})
-hook_count = sum(len(v) if isinstance(v, list) else 0 for v in hooks.values())
-
-verdict = review.get("verdict", "allow")
-risk_level = review.get("risk_level", "low")
-summary = format_review_summary(review)
-
-if verdict == "deny":
-    msg = "⚠ SETTINGS CHANGE DETECTED (Trust Review)\n" + summary
-    msg += "\n\nBlocked because risk is critical."
-    json.dump({"decision": "block", "reason": msg}, sys.stdout)
-elif verdict == "ask":
-    # ConfigChange hook only supports block/pass. For high-risk changes,
-    # block and require explicit user re-apply after review.
-    msg = "⚠ SETTINGS CHANGE REQUIRES REVIEW\n" + summary
-    msg += "\n\nRe-apply after human approval."
-    if risk_level == "high":
-        json.dump({"decision": "block", "reason": msg}, sys.stdout)
-
-sys.exit(0)

package/build/lib/hooks/context_pressure.py

@@ -1,119 +0,0 @@
-#!/usr/bin/env python3
-"""Context pressure estimation - importable module for OMG hooks."""
-
-import json
-import os
-from datetime import datetime, timezone
-
-try:
-    from runtime.context_limits import get_model_limits, compaction_trigger
-except Exception:
-    get_model_limits = None
-    compaction_trigger = None
-
-
-def _detect_model_id(context_packet=None):
-    if isinstance(context_packet, dict):
-        model = context_packet.get("model")
-        if isinstance(model, dict):
-            for key in ("id", "display_name", "name"):
-                value = str(model.get(key, "") or "").strip()
-                if value:
-                    return value
-        elif isinstance(model, str) and model.strip():
-            return model.strip()
-
-        context = context_packet.get("context")
-        if isinstance(context, dict):
-            nested_model = context.get("model")
-            if isinstance(nested_model, dict):
-                for key in ("id", "display_name", "name"):
-                    value = str(nested_model.get(key, "") or "").strip()
-                    if value:
-                        return value
-            elif isinstance(nested_model, str) and nested_model.strip():
-                return nested_model.strip()
-
-    for key in ("CLAUDE_MODEL", "OMG_MODEL_ID", "OPENAI_MODEL"):
-        value = os.environ.get(key, "").strip()
-        if value:
-            return value
-    return ""
-
-
-def _host_aware_threshold(context_packet=None):
-    model_id = _detect_model_id(context_packet)
-    if compaction_trigger is not None and get_model_limits is not None:
-        return int(compaction_trigger(model_id)), model_id, get_model_limits(model_id)
-    return 80_000, model_id, {"class_label": "128k-class"}
-
-
-def estimate_context_pressure(project_dir, context_packet=None):
-    threshold_tokens, model_id, limits = _host_aware_threshold(context_packet)
-    try:
-        settings_path = os.path.join(project_dir, "settings.json")
-        if os.path.exists(settings_path):
-            with open(settings_path, "r", encoding="utf-8") as settings_file:
-                settings = json.load(settings_file)
-            configured = settings.get("_omg", {}).get("context_budget", {}).get(
-                "pressure_threshold", threshold_tokens
-            )
-            threshold_tokens = int(configured)
-    except Exception:
-        pass
-
-    tool_count = 0
-    estimated_tokens = 0
-    ledger_path = os.path.join(project_dir, ".omg", "state", "ledger", "tool-ledger.jsonl")
-    if os.path.exists(ledger_path):
-        try:
-            with open(ledger_path, "r", encoding="utf-8", errors="ignore") as ledger_file:
-                for line in ledger_file:
-                    if line.strip():
-                        tool_count += 1
-                        estimated_tokens += _estimate_entry_tokens(line)
-        except Exception:
-            pass
-
-    is_high = estimated_tokens >= threshold_tokens if threshold_tokens > 0 else False
-
-    try:
-        pressure_path = os.path.join(project_dir, ".omg", "state", ".context-pressure.json")
-        os.makedirs(os.path.dirname(pressure_path), exist_ok=True)
-        with open(pressure_path, "w", encoding="utf-8") as pressure_file:
-            json.dump(
-                {
-                    "tool_count": tool_count,
-                    "estimated_tokens": estimated_tokens,
-                    "threshold": threshold_tokens,
-                    "threshold_tokens": threshold_tokens,
-                    "model_id": model_id,
-                    "class_label": limits.get("class_label", "128k-class"),
-                    "is_high": is_high,
-                    "ts": datetime.now(timezone.utc).isoformat(),
-                },
-                pressure_file,
-            )
-    except Exception:
-        pass
-
-    return tool_count, threshold_tokens, is_high
-
-
-def _estimate_entry_tokens(line: str) -> int:
-    baseline = max(1, len(line) // 4)
-    try:
-        entry = json.loads(line)
-    except Exception:
-        return baseline
-
-    if not isinstance(entry, dict):
-        return baseline
-
-    command_chars = len(str(entry.get("command", "")))
-    stdout_chars = len(str(entry.get("stdout_snippet", "")))
-    file_chars = len(str(entry.get("file", "")))
-    metadata_chars = len(str(entry.get("tool", ""))) + len(str(entry.get("governed_tool", "")))
-    char_total = command_chars + stdout_chars + file_chars + metadata_chars
-    estimated = max(baseline, char_total // 4)
-    return max(1, estimated)