@trac3r/oh-my-god 2.2.11

package/hooks/compression_feedback.py

@@ -0,0 +1,254 @@
+#!/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/hooks/config-guard.py

@@ -0,0 +1,193 @@
+#!/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 json
+import os
+import sys
+from importlib import import_module
+from typing import Any
+
+HOOKS_DIR = os.path.dirname(__file__)
+if HOOKS_DIR not in sys.path:
+    sys.path.insert(0, HOOKS_DIR)
+
+try:
+    _common = import_module("hooks._common")
+except ImportError:
+    _common = import_module("_common")
+
+setup_crash_handler = _common.setup_crash_handler
+json_input = _common.json_input
+_resolve_project_dir = _common._resolve_project_dir
+is_bypass_mode = _common.is_bypass_mode
+
+
+def _is_bypass_all_mode(payload: Any) -> bool:
+    if not isinstance(payload, dict):
+        return False
+    mode = str(payload.get("permission_mode", "")).strip().lower()
+    return mode == "bypassall"
+
+# 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:
+    trust_review = import_module("hooks.trust_review")
+except Exception as e:
+    print(f"[OMG] config-guard: trust_review import failed: {type(e).__name__}: {e}", file=sys.stderr)
+    sys.exit(0)
+
+format_review_summary = trust_review.format_review_summary
+regenerate_trust_manifest = trust_review.regenerate_trust_manifest
+
+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)
+
+
+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)
+
+payload_old = _extract_config_object(
+    data,
+    ("old_config", "old_settings", "old_content", "before", "old_value"),
+)
+
+# 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_mode(data):
+    sys.exit(0)
+
+review_out = regenerate_trust_manifest(
+    project_dir,
+    config_path,
+    old_config=payload_old if isinstance(payload_old, dict) else None,
+    new_config=None,
+)
+review = review_out["review"]
+
+# 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)
+    else:
+        json.dump({"decision": "pass", "reason": msg}, sys.stdout)
+
+sys.exit(0)

package/hooks/context_pressure.py

@@ -0,0 +1,119 @@
+#!/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)