@trac3r/oh-my-god 2.2.11

package/hooks/hashline-formatter-bridge.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""Hashline Formatter Bridge — reconciles sidecar hash cache after formatters run.
+
+When a post-write formatter (e.g. prettier, ruff format) modifies a file,
+the cached line hashes become stale.  This bridge detects the change and
+refreshes the sidecar cache so subsequent reads/edits use correct anchors.
+
+Feature flag: OMG_HASHLINE_ENABLED (default: False)
+"""
+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,
+    get_feature_flag,
+)
+
+setup_crash_handler("hashline-formatter-bridge")
+
+
+# --- Feature Flag ---
+
+
+def _is_enabled() -> bool:
+    """Check if hashline features are 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 detect_formatter_change(file_path: str, original_content: str, formatted_content: str) -> bool:
+    """Return True if the formatter changed the content.
+
+    Compares stripped versions of each line to ignore trivial
+    trailing-whitespace-only differences while still detecting
+    real structural changes.
+
+    Args:
+        file_path: Path to the file (for context, not read).
+        original_content: Content before formatting.
+        formatted_content: Content after formatting.
+
+    Returns:
+        True if formatted_content differs from original_content.
+    """
+    if original_content == formatted_content:
+        return False
+
+    # Compare stripped lines to ignore trivial whitespace diffs
+    orig_lines = [l.rstrip() for l in original_content.split("\n")]
+    fmt_lines = [l.rstrip() for l in formatted_content.split("\n")]
+    return orig_lines != fmt_lines
+
+
+def refresh_cache_after_format(file_path: str, formatted_content: str) -> bool:
+    """Recompute and save line hashes for newly formatted content.
+
+    Args:
+        file_path: Path to the formatted file.
+        formatted_content: The file content after formatting.
+
+    Returns:
+        True on success (or when feature is 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 = formatted_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
+
+
+def reconcile_post_format(file_path: str) -> dict:
+    """Reconcile hash cache with the current file on disk.
+
+    Reads the file, checks whether the cached mtime is stale
+    (indicating a formatter ran after the last cache write),
+    and refreshes the cache if needed.
+
+    Args:
+        file_path: Path to the file to reconcile.
+
+    Returns:
+        dict with reconciliation result:
+        - ``{"skipped": True}`` when feature is disabled
+        - ``{"refreshed": True/False, "lines_updated": int, "file": str}``
+    """
+    if not _is_enabled():
+        return {"skipped": True}
+
+    try:
+        injector = _get_injector()
+        _get_cached_hashes = injector._get_cached_hashes
+        _line_hash_id = injector._line_hash_id
+        _cache_hashes = injector._cache_hashes
+    except Exception:
+        return {"refreshed": False, "lines_updated": 0, "file": file_path}
+
+    try:
+        abs_path = os.path.abspath(file_path)
+        if not os.path.exists(abs_path):
+            return {"refreshed": False, "lines_updated": 0, "file": file_path}
+
+        # Read current content from disk
+        with open(abs_path, "r", encoding="utf-8", errors="replace") as f:
+            content = f.read()
+
+        # Check if cache exists — if _get_cached_hashes returns None,
+        # cache is either missing or mtime doesn't match (formatter ran).
+        cached = _get_cached_hashes(file_path)
+        if cached is not None:
+            # Cache is still valid (mtime matches) — no refresh needed
+            return {"refreshed": False, "lines_updated": 0, "file": file_path}
+
+        # Cache is stale or missing — refresh
+        lines = 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 {"refreshed": True, "lines_updated": len(lines), "file": file_path}
+    except Exception:
+        return {"refreshed": False, "lines_updated": 0, "file": file_path}
+
+
+# --- Write-tool names that trigger reconciliation ---
+
+_WRITE_TOOLS = frozenset({
+    "Write", "Edit", "MultiEdit",
+    "mcp__filesystem__write_file",
+    "mcp__filesystem__edit_file",
+})
+
+
+# --- Hook Entry Point ---
+
+
+def main():
+    """PostToolUse hook stdin/stdout entry point.
+
+    Reads JSON from stdin::
+
+        {"tool_name": "Write", "tool_input": {"file_path": "..."}}
+
+    If tool_name is a write tool and OMG_HASHLINE_ENABLED is set,
+    runs ``reconcile_post_format`` to refresh the hash cache after
+    any post-write formatter may have modified the file.
+
+    Always exits 0 — never raises.
+    """
+    if not _is_enabled():
+        sys.exit(0)
+
+    data = json_input()
+    if not isinstance(data, dict):
+        sys.exit(0)
+
+    tool_name = data.get("tool_name", "")
+    if tool_name not in _WRITE_TOOLS:
+        sys.exit(0)
+
+    tool_input = data.get("tool_input", {})
+    if not isinstance(tool_input, dict):
+        sys.exit(0)
+
+    file_path = tool_input.get("file_path", tool_input.get("filePath", ""))
+    if not file_path:
+        sys.exit(0)
+
+    try:
+        result = reconcile_post_format(file_path)
+        json.dump(result, sys.stdout)
+    except Exception:
+        pass  # Graceful degradation — never crash
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/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/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()