@trac3er/oh-my-god 2.0.0 → 2.0.2

package/hooks/circuit-breaker.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""
+PostToolUse Hook: Circuit Breaker + Auto-Escalation (v4)
+Key v4 change: After 3 failures, automatically SUGGESTS Codex/Gemini escalation
+instead of just saying "stop". Actionable, not just blocking.
+"""
+import json, sys, os
+from datetime import datetime, timezone, timedelta
+
+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
+from state_migration import resolve_state_dir
+
+setup_crash_handler("circuit-breaker", fail_closed=False)
+
+# Domain-aware routing hints: pattern prefix → suggested model
+DOMAIN_MODEL_HINTS = {
+    'Bash:pytest': 'codex',
+    'Bash:npm': 'codex',
+    'Bash:python': 'codex',
+    'Write:': 'codex',
+    'Edit:': 'codex',
+}
+
+
+def _get_domain_hint(pk: str) -> str:
+    """Return model hint for a pattern key, or empty string."""
+    for prefix, model in DOMAIN_MODEL_HINTS.items():
+        if pk.startswith(prefix):
+            return model
+    return ''
+
+data = json_input()
+
+tool = data.get("tool_name", "")
+tool_input = data.get("tool_input", {})
+tool_response = data.get("tool_response", {})
+project_dir = _resolve_project_dir()
+
+ledger_dir = resolve_state_dir(project_dir, "state/ledger", "ledger")
+tracker_path = os.path.join(ledger_dir, "failure-tracker.json")
+os.makedirs(os.path.dirname(tracker_path), exist_ok=True)
+
+# Determine failure
+is_failure = False
+if tool == "Bash":
+    ec = None
+    if isinstance(tool_response, dict):
+        ec = tool_response.get("exitCode", tool_response.get("exit_code"))
+    if ec is not None and ec != 0:
+        is_failure = True
+elif tool in ("Write", "Edit", "MultiEdit"):
+    if isinstance(tool_response, dict) and not tool_response.get("success", True):
+        is_failure = True
+
+# Pattern key — normalized to prevent duplicates
+# "npm test" and "npm run test" should be the same failure pattern
+pattern_key = tool
+if tool == "Bash":
+    cmd = tool_input.get("command", "").strip()
+    # Normalize: strip common prefixes, reduce to base command
+    cmd_clean = cmd
+    # Strip package manager prefixes: npx, pnpm, yarn, bunx
+    cmd_clean = cmd_clean.replace("npx ", "").replace("pnpm ", "npm ").replace("yarn ", "npm ").replace("bunx ", "")
+    # Strip python -m X → X (e.g., "python3 -m pytest" → "pytest")
+    if cmd_clean.startswith("python3 -m "):
+        cmd_clean = cmd_clean.replace("python3 -m ", "", 1)
+    elif cmd_clean.startswith("python -m "):
+        cmd_clean = cmd_clean.replace("python -m ", "", 1)
+    words = cmd_clean.split()[:3]  # first 3 words for more specificity
+    # Remove common noise: run, exec, --
+    words = [w for w in words if not w.startswith("-") and w not in ("run", "exec")][:2]
+    pattern_key = f"Bash:{' '.join(words)}" if words else f"Bash:{cmd[:30]}"
+elif tool in ("Write", "Edit", "MultiEdit"):
+    fp = tool_input.get("file_path", "")
+    # Normalize: use basename to avoid path-length variants
+    pattern_key = f"{tool}:{os.path.basename(fp)}" if fp else tool
+pattern_key = pattern_key[:120].replace("\n", " ")
+
+# Load tracker
+tracker = {}
+if os.path.exists(tracker_path):
+    try:
+        with open(tracker_path, "r") as f:
+            tracker = json.load(f)
+        if not isinstance(tracker, dict):
+            tracker = {}
+    except Exception:
+        tracker = {}
+
+# Evict stale (24h) + cap 100
+now = datetime.now(timezone.utc)
+cutoff = now - timedelta(hours=24)
+
+
+def _parse_ts(ts_str):
+    """Parse ISO timestamp string to datetime, returning None on failure."""
+    try:
+        # Handle both Z-suffix and +00:00 formats
+        ts = ts_str.replace("Z", "+00:00") if ts_str.endswith("Z") else ts_str
+        return datetime.fromisoformat(ts)
+    except (ValueError, TypeError, AttributeError):
+        return None
+
+
+def _effective_count(entry: dict[str, object], now: datetime) -> float:
+    """Apply time-decay: failures >30 min old count as 0.5x."""
+    last_failure = entry.get('last_failure', '')
+    last_ts = _parse_ts(last_failure if isinstance(last_failure, str) else '')
+    raw_count = entry.get('count', 0)
+    count_value = float(raw_count) if isinstance(raw_count, (int, float)) else 0.0
+    if last_ts is None:
+        return count_value
+    age_minutes = (now - last_ts).total_seconds() / 60
+    if age_minutes > 30:
+        return count_value * 0.5
+    return count_value
+
+
+tracker = {k: v for k, v in tracker.items()
+           if isinstance(v, dict) and (_parse_ts(v.get("last_failure", "")) or cutoff) >= cutoff}
+if len(tracker) > 100:
+    for k in sorted(tracker, key=lambda x: tracker[x].get("last_failure", ""))[:-100]:
+        del tracker[k]
+
+if is_failure:
+    entry_raw = tracker.get(pattern_key, {"count": 0, "errors": []})
+    if not isinstance(entry_raw, dict):
+        entry_raw = {"count": 0, "errors": []}
+    entry: dict[str, object] = dict(entry_raw)
+    entry_count = entry.get("count", 0)
+    count_value = entry_count if isinstance(entry_count, (int, float)) else 0
+    entry["count"] = count_value + 1
+    entry["last_failure"] = now.isoformat()
+
+    err = ""
+    if isinstance(tool_response, dict):
+        err = str(tool_response.get("stderr", tool_response.get("stdout", "")))[:200].strip()
+    errors = entry.get("errors", [])
+    if not isinstance(errors, list):
+        errors = []
+    # Deduplicate: don't store the same error message twice in a row
+    if err and (not errors or errors[-1] != err):
+        errors.append(err)
+    entry["errors"] = errors[-3:]  # keep last 3 unique errors
+    tracker[pattern_key] = entry
+
+    try:
+        import fcntl
+        # Open read+write without truncating, acquire lock, THEN truncate and write.
+        # This prevents data loss if lock acquisition fails after truncation.
+        fd = open(tracker_path, "a+")
+        fcntl.flock(fd.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        fd.seek(0)
+        fd.truncate()
+        json.dump(tracker, fd, indent=2)
+        fd.flush()
+        fcntl.flock(fd.fileno(), fcntl.LOCK_UN)
+        fd.close()
+    except (ImportError, BlockingIOError):
+        # Fallback: write without lock (better than losing data)
+        try:
+            with open(tracker_path, "w") as f:
+                json.dump(tracker, f, indent=2)
+        except Exception:
+            pass
+    except Exception:
+        pass
+
+    count = entry["count"]
+    effective_count = _effective_count(entry, now)
+    domain_hint = _get_domain_hint(pattern_key)
+    recent_errs = "\n".join(f"  - {e}" for e in entry["errors"] if e)
+
+    if effective_count >= 5:
+        print(
+            f"CIRCUIT BREAKER: '{pattern_key}' failed {count}x (effective {effective_count:.1f}x).\n"
+            f"STOP. This approach is broken.\n"
+            f"{recent_errs}\n\n"
+            f"Domain hint: {domain_hint or 'none'}\n"
+            f"ESCALATE NOW — pick one:\n"
+            f"  /OMG:escalate codex \"Debug: {pattern_key} fails with {entry['errors'][-1][:80]}\"\n"
+            f"  /OMG:escalate gemini \"Review: approach for {pattern_key}\"\n"
+            f"  Ask the user for a completely different approach\n"
+            f"  Skip this step: mark [!] in checklist and move on",
+            file=sys.stderr
+        )
+        # NOTE: exit(0), not exit(2). Non-zero exits crash sibling hooks
+        # ("Sibling tool call errored"). The warning is in stderr.
+        sys.exit(0)
+
+    elif effective_count >= 3:
+        print(
+            f"CIRCUIT BREAKER WARNING: '{pattern_key}' failed {count}x (effective {effective_count:.1f}x).\n"
+            f"Last error: {entry['errors'][-1][:150] if entry['errors'] else 'unknown'}\n\n"
+            f"Domain hint: {domain_hint or 'none'}\n"
+            f"STOP auto-retrying. Try:\n"
+            f"  1. Fundamentally different approach\n"
+            f"  2. /OMG:escalate codex \"Why does {pattern_key} keep failing?\"\n"
+            f"  3. Ask the user",
+            file=sys.stderr
+        )
+        sys.exit(0)
+
+else:
+    # On success, clear this pattern AND similar variants
+    # Helper to normalize a tracker key by re-normalizing the command part
+    def _normalize_tracker_key(pk):
+        """Normalize a tracker key by applying the same rules as pattern_key generation."""
+        if not pk.startswith("Bash:"):
+            return pk
+        
+        cmd = pk[5:]  # Remove "Bash:" prefix
+        # Apply the same normalization as in pattern_key generation
+        cmd_clean = cmd
+        cmd_clean = cmd_clean.replace("npx ", "").replace("pnpm ", "npm ").replace("yarn ", "npm ").replace("bunx ", "")
+        if cmd_clean.startswith("python3 -m "):
+            cmd_clean = cmd_clean.replace("python3 -m ", "", 1)
+        elif cmd_clean.startswith("python -m "):
+            cmd_clean = cmd_clean.replace("python -m ", "", 1)
+        words = cmd_clean.split()[:3]
+        words = [w for w in words if not w.startswith("-") and w not in ("run", "exec")][:2]
+        normalized_cmd = ' '.join(words) if words else cmd[:30]
+        return f"Bash:{normalized_cmd}"
+    
+    normalized_pattern_key = _normalize_tracker_key(pattern_key)
+    changed = False
+    keys_to_remove = []
+    
+    for k in tracker:
+        # Normalize both keys for comparison
+        normalized_k = _normalize_tracker_key(k)
+        if normalized_k == normalized_pattern_key:
+            keys_to_remove.append(k)
+    
+    for k in keys_to_remove:
+        del tracker[k]
+        changed = True
+    
+    if changed:
+        try:
+            with open(tracker_path, "w") as f:
+                json.dump(tracker, f, indent=2)
+        except Exception:
+            pass
+        _recovery_path = os.path.join(ledger_dir, 'recovery.jsonl')
+        try:
+            import json as _json
+            _rec = _json.dumps({
+                'pattern': pattern_key,
+                'recovered_at': now.isoformat(),
+                'cleared_count': len(keys_to_remove),
+            })
+            with open(_recovery_path, 'a') as _rf:
+                _rf.write(_rec + '\n')
+            try:
+                with open(_recovery_path, 'r') as _rf:
+                    _lines = _rf.readlines()
+                if len(_lines) > 200:
+                    with open(_recovery_path, 'w') as _rf:
+                        _rf.writelines(_lines[-200:])
+            except OSError:
+                pass
+        except Exception:
+            pass
+
+sys.exit(0)

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)