@trac3er/oh-my-god 2.2.3 → 2.2.5

package/build/lib/hooks/hashline-formatter-bridge.py

@@ -1,224 +0,0 @@
-#!/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/build/lib/hooks/hashline-injector.py

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

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