@trac3er/oh-my-god 2.0.4 → 2.0.7

package/build/lib/hooks/hashline-injector.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+"""Hashline Injector — injects content-hash anchors into file content on read.
+
+Each line gets a tag: `{line_number}#{2-char-id}|{original line}`
+where the 2-char ID is derived from SHA-256 of the line content mapped to
+the charset ZPMQVRWSNKTXJBYH (16 chars, 4-bit nibbles of first hash byte).
+
+Uses a sidecar cache at `.omg/state/hashline_cache.json` to avoid
+regenerating hashes for unchanged files. Never modifies original files.
+
+Feature flag: OMG_HASHLINE_ENABLED (default: False)
+"""
+import hashlib
+import json
+import os
+import re
+import sys
+import time
+
+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,
+    get_feature_flag,
+    get_project_dir,
+    atomic_json_write,
+)
+
+setup_crash_handler("hashline-injector")
+
+# --- Constants ---
+
+# 16-char charset for 4-bit nibble mapping
+HASH_CHARSET = "ZPMQVRWSNKTXJBYH"
+
+# Regex to strip hashline prefix: digits + # + 2 uppercase letters + |
+_HASHLINE_RE = re.compile(r"^\d+#[A-Z]{2}\|")
+
+# Sidecar cache path (relative to project dir)
+_CACHE_REL_PATH = os.path.join(".omg", "state", "hashline_cache.json")
+
+
+# --- Core Functions ---
+
+
+def _line_hash_id(line: str) -> str:
+    """Generate 2-char hash ID from line content.
+
+    Takes first byte of SHA-256 digest, splits into two 4-bit nibbles,
+    maps each nibble to HASH_CHARSET.
+    """
+    digest = hashlib.sha256(line.encode("utf-8", errors="replace")).digest()
+    first_byte = digest[0]
+    high_nibble = (first_byte >> 4) & 0x0F
+    low_nibble = first_byte & 0x0F
+    return HASH_CHARSET[high_nibble] + HASH_CHARSET[low_nibble]
+
+
+def inject_hashlines(content: str, file_path: str = None) -> str:
+    """Add hash anchors to each line of content.
+
+    Format: `{line_num}#{hash_id}|{original_line}` (1-indexed)
+
+    Args:
+        content: File content string
+        file_path: Optional file path for caching. If provided and the file
+                   exists, hashes are cached to `.omg/state/hashline_cache.json`.
+
+    Returns:
+        Content with hash anchors prepended to each line.
+        Returns content unchanged if OMG_HASHLINE_ENABLED is False.
+    """
+    if not _is_enabled():
+        return content
+
+    # Check cache first
+    if file_path:
+        cached = _get_cached_hashes(file_path)
+        if cached is not None:
+            return _apply_cached_hashes(content, cached)
+
+    lines = content.split("\n")
+    result = []
+    line_hashes = {}
+
+    for i, line in enumerate(lines, start=1):
+        hash_id = _line_hash_id(line)
+        line_hashes[str(i)] = hash_id
+        result.append(f"{i}#{hash_id}|{line}")
+
+    # Cache if file_path provided
+    if file_path:
+        _cache_hashes(file_path, line_hashes)
+
+    return "\n".join(result)
+
+
+def strip_hashlines(content: str) -> str:
+    """Remove hash anchors from content, restoring original text.
+
+    Strips `^\\d+#[A-Z]{2}\\|` prefix from each line.
+
+    Args:
+        content: Content with hash anchors
+
+    Returns:
+        Original content without hash anchors.
+    """
+    lines = content.split("\n")
+    result = []
+    for line in lines:
+        result.append(_HASHLINE_RE.sub("", line))
+    return "\n".join(result)
+
+
+def _apply_cached_hashes(content: str, line_hashes: dict) -> str:
+    """Apply cached hash IDs to content lines."""
+    lines = content.split("\n")
+    result = []
+    for i, line in enumerate(lines, start=1):
+        hash_id = line_hashes.get(str(i))
+        if hash_id is None:
+            # Line count changed — cache is stale, regenerate
+            hash_id = _line_hash_id(line)
+        result.append(f"{i}#{hash_id}|{line}")
+    return "\n".join(result)
+
+
+# --- Sidecar Cache ---
+
+
+def _get_cache_path() -> str:
+    """Get absolute path to hashline cache file."""
+    return os.path.join(get_project_dir(), _CACHE_REL_PATH)
+
+
+def _load_cache() -> dict:
+    """Load the entire hashline cache from disk. Returns empty dict on failure."""
+    cache_path = _get_cache_path()
+    try:
+        if not os.path.exists(cache_path):
+            return {}
+        with open(cache_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def _get_cached_hashes(file_path: str):
+    """Get cached line hashes for a file, if still valid.
+
+    Args:
+        file_path: Path to the source file
+
+    Returns:
+        dict mapping line number (str) -> hash_id, or None if not cached
+        or if the file's mtime has changed (cache invalidation).
+    """
+    try:
+        abs_path = os.path.abspath(file_path)
+        if not os.path.exists(abs_path):
+            return None
+
+        cache = _load_cache()
+        entry = cache.get(abs_path)
+        if entry is None:
+            return None
+
+        # Check mtime for invalidation
+        current_mtime = os.path.getmtime(abs_path)
+        cached_mtime = entry.get("mtime", 0)
+        if abs(current_mtime - cached_mtime) > 0.001:
+            return None
+
+        return entry.get("line_hashes")
+    except Exception:
+        return None
+
+
+def _cache_hashes(file_path: str, line_hashes: dict) -> None:
+    """Save line hashes to sidecar cache with mtime for invalidation.
+
+    Args:
+        file_path: Path to the source file
+        line_hashes: dict mapping line number (str) -> hash_id
+    """
+    try:
+        abs_path = os.path.abspath(file_path)
+        cache = _load_cache()
+
+        mtime = 0.0
+        if os.path.exists(abs_path):
+            mtime = os.path.getmtime(abs_path)
+
+        cache[abs_path] = {
+            "mtime": mtime,
+            "line_hashes": line_hashes,
+        }
+
+        atomic_json_write(_get_cache_path(), cache)
+    except Exception:
+        pass  # Never crash on cache write failure
+
+
+# --- Feature Flag ---
+
+
+def _is_enabled() -> bool:
+    """Check if hashline injection is enabled.
+
+    Resolution order: OMG_HASHLINE_ENABLED env var → settings.json → False
+    """
+    # Fast path: check env var directly
+    env_val = os.environ.get("OMG_HASHLINE_ENABLED", "").lower()
+    if env_val in ("1", "true", "yes"):
+        return True
+    if env_val in ("0", "false", "no"):
+        return False
+    # Slow path: check settings.json via get_feature_flag
+    return get_feature_flag("HASHLINE", default=False)
+
+
+# --- Hook Entry Point ---
+
+
+def main():
+    """Hook stdin/stdout entry point for Claude Code PreToolUse hooks.
+
+    Reads JSON from stdin with tool_input containing file content.
+    If hashline injection is enabled and tool is a file read, injects
+    hash anchors into the content.
+    Writes modified tool input back to stdout.
+    Always exits 0 — never raises.
+    """
+    if not _is_enabled():
+        sys.exit(0)
+
+    data = json_input()
+    if not isinstance(data, dict):
+        sys.exit(0)
+
+    # Only inject for file-read tools
+    tool_name = data.get("tool_name", "")
+    if tool_name not in ("Read", "mcp__filesystem__read_file",
+                          "mcp__filesystem__read_text_file"):
+        sys.exit(0)
+
+    tool_input = data.get("tool_input", {})
+    if not isinstance(tool_input, dict):
+        sys.exit(0)
+
+    content = tool_input.get("content", "")
+    file_path = tool_input.get("file_path", tool_input.get("filePath", ""))
+
+    if not content:
+        sys.exit(0)
+
+    try:
+        injected = inject_hashlines(content, file_path or None)
+        tool_input["content"] = injected
+        data["tool_input"] = tool_input
+        json.dump(data, sys.stdout)
+    except Exception:
+        pass  # Graceful degradation — never crash
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/build/lib/hooks/hashline-validator.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""Hashline Validator — validates edit targets against stored hash anchors.
+
+Validates that ``line_ref`` (e.g. ``"11#VK"``) matches the cached hash for
+that line before allowing an edit.  Rejects mismatched edits with a clear
+error dict.  Updates cache after successful edits.
+
+Feature flag: OMG_HASHLINE_ENABLED (default: False)
+"""
+import json
+import os
+import re
+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,
+    get_feature_flag,
+)
+
+setup_crash_handler("hashline-validator")
+
+# --- Constants ---
+
+# Valid line_ref: digits + # + exactly 2 chars from HASH_CHARSET
+_LINE_REF_RE = re.compile(r"^\d+#[ZPMQVRWSNKTXJBYH]{2}$")
+
+
+# --- Feature Flag ---
+
+
+def _is_enabled() -> bool:
+    """Check if hashline validation is enabled.
+
+    Resolution order: OMG_HASHLINE_ENABLED env var → settings.json → False
+    """
+    env_val = os.environ.get("OMG_HASHLINE_ENABLED", "").lower()
+    if env_val in ("1", "true", "yes"):
+        return True
+    if env_val in ("0", "false", "no"):
+        return False
+    return get_feature_flag("HASHLINE", default=False)
+
+
+# --- Lazy Imports from hashline-injector ---
+
+_injector = None
+
+
+def _get_injector():
+    """Lazy-load hashline-injector module."""
+    global _injector
+    if _injector is None:
+        import importlib
+        _injector = importlib.import_module("hashline-injector")
+    return _injector
+
+
+# --- Core Functions ---
+
+
+def validate_line_ref_format(line_ref: str) -> bool:
+    """Return True if *line_ref* matches ``'{line_num}#{2-char hash_id}'``.
+
+    Hash ID characters must belong to the charset ``ZPMQVRWSNKTXJBYH``.
+
+    Args:
+        line_ref: Line reference string (e.g. ``"11#VK"``)
+
+    Returns:
+        True if format is valid, False otherwise.
+    """
+    if not isinstance(line_ref, str):
+        return False
+    return bool(_LINE_REF_RE.match(line_ref))
+
+
+def validate_edit(file_path: str, line_ref: str, expected_line: str) -> dict:
+    """Validate a hash anchor before allowing an edit.
+
+    Args:
+        file_path: Path to the file being edited.
+        line_ref: Line reference ``"{line_num}#{hash_id}"`` (e.g. ``"11#VK"``).
+        expected_line: The expected content of the line (context, not used
+                       for hash matching itself).
+
+    Returns:
+        dict with validation result — always contains ``"valid"`` key:
+
+        * Feature disabled → ``{"valid": True, "skipped": True}``
+        * No cache available → ``{"valid": True, "uncached": True}``
+        * Hash match → ``{"valid": True, "line": <int>}``
+        * Hash mismatch → ``{"valid": False, "error": "HASH_MISMATCH",
+          "line": <int>, "expected": <str>, "actual": <str>}``
+        * Bad format → ``{"valid": False, "error": "INVALID_LINE_REF",
+          "line_ref": <str>}``
+    """
+    # Skip when disabled
+    if not _is_enabled():
+        return {"valid": True, "skipped": True}
+
+    # Validate format
+    if not validate_line_ref_format(line_ref):
+        return {"valid": False, "error": "INVALID_LINE_REF", "line_ref": line_ref}
+
+    # Parse line_ref
+    parts = line_ref.split("#")
+    line_num = int(parts[0])
+    hash_id = parts[1]
+
+    # Load cache via injector
+    try:
+        injector = _get_injector()
+        cached_hashes = injector._get_cached_hashes(file_path)
+    except Exception:
+        # Injector unavailable — cannot validate
+        return {"valid": True, "uncached": True}
+
+    if cached_hashes is None:
+        return {"valid": True, "uncached": True}
+
+    # Look up the line in the cache
+    stored_hash = cached_hashes.get(str(line_num))
+    if stored_hash is None:
+        # Line number not in cache (file may have grown since last cache)
+        return {"valid": True, "uncached": True}
+
+    # Compare
+    if stored_hash != hash_id:
+        return {
+            "valid": False,
+            "error": "HASH_MISMATCH",
+            "line": line_num,
+            "expected": hash_id,
+            "actual": stored_hash,
+        }
+
+    return {"valid": True, "line": line_num}
+
+
+def update_hashes_after_edit(file_path: str, new_content: str) -> bool:
+    """Refresh the hash cache after a successful edit.
+
+    Re-generates line hashes for *new_content* and updates the sidecar
+    cache (``hashline_cache.json``) for *file_path*.
+
+    Args:
+        file_path: Path to the edited file.
+        new_content: The file content after the edit.
+
+    Returns:
+        True on success (or when disabled), False on error.
+    """
+    if not _is_enabled():
+        return True
+
+    try:
+        injector = _get_injector()
+        _line_hash_id = injector._line_hash_id
+        _cache_hashes = injector._cache_hashes
+    except Exception:
+        return False
+
+    try:
+        lines = new_content.split("\n")
+        line_hashes = {}
+        for i, line in enumerate(lines, start=1):
+            line_hashes[str(i)] = _line_hash_id(line)
+
+        _cache_hashes(file_path, line_hashes)
+        return True
+    except Exception:
+        return False
+
+
+# --- Hook Entry Point ---
+
+
+def main():
+    """Hook stdin/stdout entry point.
+
+    Reads JSON from stdin::
+
+        {"file_path": "...", "line_ref": "11#VK", "expected_line": "..."}
+
+    Calls :func:`validate_edit` and writes the result dict to stdout.
+    Always exits 0 — never raises.
+    """
+    if not _is_enabled():
+        json.dump({"valid": True, "skipped": True}, sys.stdout)
+        sys.exit(0)
+
+    data = json_input()
+    if not isinstance(data, dict):
+        json.dump({"valid": False, "error": "INVALID_INPUT"}, sys.stdout)
+        sys.exit(0)
+
+    file_path = data.get("file_path", "")
+    line_ref = data.get("line_ref", "")
+    expected_line = data.get("expected_line", "")
+
+    try:
+        result = validate_edit(file_path, line_ref, expected_line)
+        json.dump(result, sys.stdout)
+    except Exception:
+        json.dump({"valid": False, "error": "INTERNAL_ERROR"}, sys.stdout)
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/build/lib/hooks/idle-detector.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""
+Stop Hook: Idle Detector (v1)
+
+Detects when an agent has gone idle with incomplete todos.
+Reads .omg/state/todo_progress.json (from todo-state-tracker)
+and writes continuation signal to .omg/state/idle_signal.json.
+
+Detection only — does not block the stop.
+
+Feature flag: OMG_IDLE_DETECTION_ENABLED (default: False)
+"""
+import json
+import sys
+import os
+from datetime import datetime, timezone
+
+HOOKS_DIR = os.path.dirname(__file__)
+if HOOKS_DIR not in sys.path:
+    sys.path.insert(0, HOOKS_DIR)
+
+from _common import (  # noqa: E402
+    setup_crash_handler,
+    json_input,
+    get_project_dir,
+    get_feature_flag,
+    atomic_json_write,
+)
+
+setup_crash_handler("idle-detector", fail_closed=False)
+
+# Feature flag check — exit cleanly if disabled
+if not get_feature_flag("IDLE_DETECTION", default=False):
+    sys.exit(0)
+
+# Consume stdin (stop hooks receive JSON input)
+_data = json_input()
+
+project_dir = get_project_dir()
+todo_path = os.path.join(project_dir, ".omg", "state", "todo_progress.json")
+signal_path = os.path.join(project_dir, ".omg", "state", "idle_signal.json")
+
+
+def _write_signal(idle: bool, incomplete: list | None = None, call_count: int = 0):
+    """Write idle signal state atomically."""
+    items = incomplete or []
+    atomic_json_write(signal_path, {
+        "idle_detected": idle,
+        "incomplete_count": len(items),
+        "incomplete_items": items[:3],
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "trigger": "stop_hook",
+        "call_count": call_count,
+    })
+
+
+# --- Read todo progress ---
+todo_state = None
+if os.path.exists(todo_path):
+    try:
+        with open(todo_path, "r", encoding="utf-8") as f:
+            todo_state = json.load(f)
+    except Exception:
+        todo_state = None
+
+# No todo file or malformed → not idle
+if not isinstance(todo_state, dict):
+    _write_signal(False)
+    sys.exit(0)
+
+incomplete = todo_state.get("incomplete", [])
+if not isinstance(incomplete, list):
+    incomplete = []
+
+# No incomplete items → not idle
+if not incomplete:
+    _write_signal(False)
+    sys.exit(0)
+
+# --- Check call counter from existing signal ---
+call_count = 0
+if os.path.exists(signal_path):
+    try:
+        with open(signal_path, "r", encoding="utf-8") as f:
+            existing = json.load(f)
+        if isinstance(existing, dict):
+            call_count = existing.get("call_count", 0)
+    except Exception:
+        call_count = 0
+
+# Idle = incomplete todos AND hook has been called at least once before
+idle_detected = call_count >= 1
+
+_write_signal(idle_detected, incomplete, call_count + 1)
+sys.exit(0)