@trac3er/oh-my-god 2.2.3 → 2.2.5

package/build/lib/hooks/pre-compact.py

@@ -1,470 +0,0 @@
-#!/usr/bin/env python3
-"""PreCompact Hook — OMG Standalone state preservation.
-
-1) Snapshot key files from .omg/state (fallback .omc via migration)
-2) Auto-generate handoff files in .omg/state
-3) JetBrains hybrid summarization (feature-flagged: CONTEXT_MANAGER)
-"""
-import json
-import importlib
-import math
-import os
-import re
-import shutil
-import subprocess
-import sys
-from datetime import datetime
-
-try:
-    from hooks.state_migration import resolve_state_file, resolve_state_dir
-    from hooks._common import _resolve_project_dir, get_feature_flag
-    from hooks._protected_context import collect_protected_context
-except ImportError:
-    _state_migration = importlib.import_module("state_migration")
-    _common = importlib.import_module("_common")
-    resolve_state_file = _state_migration.resolve_state_file
-    resolve_state_dir = _state_migration.resolve_state_dir
-    _resolve_project_dir = _common._resolve_project_dir
-    get_feature_flag = _common.get_feature_flag
-    try:
-        _protected_ctx = importlib.import_module("_protected_context")
-        collect_protected_context = _protected_ctx.collect_protected_context
-    except Exception:
-        collect_protected_context = None
-
-try:
-    from runtime.context_limits import get_model_limits, compaction_trigger
-except Exception:
-    get_model_limits = None
-    compaction_trigger = None
-
-
-MAX_SNAPSHOT_BYTES = int(os.environ.get("OMG_PRECOMPACT_MAX_SNAPSHOT_BYTES", "262144"))
-GIT_DIFF_TIMEOUT_SEC = int(os.environ.get("OMG_PRECOMPACT_GIT_DIFF_TIMEOUT_SEC", "1"))
-
-
-# ---------------------------------------------------------------------------
-# Pure utility functions (importable for testing)
-# ---------------------------------------------------------------------------
-
-def read_file(path, max_lines=None):
-    try:
-        if not os.path.exists(path):
-            return None
-        with open(path, "r", encoding="utf-8", errors="ignore") as f:
-            content = f.read().strip()
-        if not content:
-            return None
-        if max_lines:
-            return "\n".join(content.split("\n")[:max_lines])
-        return content
-    except Exception:
-        return None
-
-
-def read_cache(paths):
-    cache = {}
-    for path in paths:
-        cache[path] = read_file(path)
-    return cache
-
-
-def first_lines(text, max_lines):
-    if not text:
-        return None
-    if not max_lines:
-        return text
-    return "\n".join(text.splitlines()[:max_lines])
-
-
-def snapshot_file(src_path, dst_path, max_bytes):
-    os.makedirs(os.path.dirname(dst_path), exist_ok=True)
-    try:
-        size = os.path.getsize(src_path)
-    except OSError:
-        return False
-
-    if max_bytes <= 0 or size <= max_bytes:
-        shutil.copy2(src_path, dst_path)
-        return True
-
-    with open(src_path, "rb") as src_f:
-        raw = src_f.read(max_bytes)
-    note = (
-        f"\n\n[TRUNCATED by pre-compact: original_bytes={size}, kept_bytes={len(raw)}]"
-    ).encode("utf-8")
-    with open(dst_path, "wb") as dst_f:
-        dst_f.write(raw)
-        dst_f.write(note)
-    return True
-
-
-# ---------------------------------------------------------------------------
-# JetBrains hybrid summarization (Dec 2025 empirical strategy)
-# ---------------------------------------------------------------------------
-
-# Regex for common source file extensions
-_FILE_PATH_RE = re.compile(
-    r"(?:[\w./-]+/)?[\w.-]+\."
-    r"(?:py|ts|js|tsx|jsx|json|yaml|yml|md|txt|sh|toml|cfg|ini|sql|html|css|go|rs|java|rb|c|h|cpp)"
-)
-
-# Keywords indicating causal relationships / decisions
-_CAUSAL_RE = re.compile(
-    r"\b(?:decided|chose|because|therefore|fixed|resolved|implemented|"
-    r"created|added|removed|deleted|changed|updated|refactored)\b",
-    re.IGNORECASE,
-)
-
-
-def _extract_entities(text):
-    """Extract file paths and causal decision sentences from text.
-
-    Returns (file_paths: list[str], decisions: list[str]).
-    """
-    files = list(dict.fromkeys(_FILE_PATH_RE.findall(text)))  # dedupe, preserve order
-    sentences = re.split(r"[.!?\n]", text)
-    decisions = [
-        s.strip()
-        for s in sentences
-        if _CAUSAL_RE.search(s) and len(s.strip()) > 5
-    ]
-    return files, decisions
-
-
-def _summarize_batch(batch, batch_num, start_idx, end_idx):
-    """Summarize a batch of turns into a single string.
-
-    Format: "Batch N (turns X-Y): [files] [decisions]"
-    """
-    combined_text = " ".join(t.get("content", "") for t in batch)
-    files, decisions = _extract_entities(combined_text)
-
-    parts = [f"Batch {batch_num} (turns {start_idx}-{end_idx}):"]
-    if files:
-        parts.append(f"[files: {', '.join(files[:10])}]")
-    if decisions:
-        # Keep at most 3 decision excerpts, truncated
-        excerpts = [d[:80] for d in decisions[:3]]
-        parts.append(f"[decisions: {'; '.join(excerpts)}]")
-    if not files and not decisions:
-        parts.append("[no notable entities]")
-
-    return " ".join(parts)
-
-
-def _apply_hybrid_summarization(turns, config):
-    """Apply JetBrains hybrid summarization strategy.
-
-    Args:
-        turns: List of turn dicts (index 0 = newest), each with 'role' and 'content'.
-        config: Dict with keys:
-            - full_turns: Number of most-recent turns to keep verbatim (default 10)
-            - summarize_turns: Max turn index for summarization window (default 50)
-            - batch_size: Number of turns per summary batch (default 21)
-
-    Returns:
-        Dict with:
-            - full_turns: List of turn dicts kept verbatim
-            - summaries: List of batch summary strings
-            - discarded_count: Number of turns beyond the summarization window
-    """
-    full_n = config.get("full_turns", 10)
-    summarize_n = config.get("summarize_turns", 50)
-    batch_size = config.get("batch_size", 21)
-
-    total = len(turns)
-
-    if total == 0:
-        return {"full_turns": [], "summaries": [], "discarded_count": 0}
-
-    # Latest turns kept verbatim
-    full_end = min(full_n, total)
-    full_turns = turns[:full_end]
-
-    # Middle range to summarize: turns[full_end:summarize_n]
-    summarize_end = min(summarize_n, total)
-    middle_turns = turns[full_end:summarize_end]
-
-    # Discarded: turns[summarize_n:]
-    discarded_count = max(0, total - summarize_n)
-
-    # Batch the middle turns
-    summaries = []
-    if middle_turns and batch_size > 0:
-        num_batches = math.ceil(len(middle_turns) / batch_size)
-        for b in range(num_batches):
-            batch_start = b * batch_size
-            batch_end = min((b + 1) * batch_size, len(middle_turns))
-            batch = middle_turns[batch_start:batch_end]
-
-            # Absolute indices (relative to original turns list)
-            abs_start = full_end + batch_start
-            abs_end = full_end + batch_end - 1
-
-            summary = _summarize_batch(batch, b + 1, abs_start, abs_end)
-            summaries.append(summary)
-
-    return {
-        "full_turns": full_turns,
-        "summaries": summaries,
-        "discarded_count": discarded_count,
-    }
-
-
-def _load_context_budget_config(project_dir):
-    """Load context_budget config from settings.json, with defaults."""
-    defaults = {"full_turns": 10, "summarize_turns": 50, "batch_size": 21}
-    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 f:
-                settings = json.load(f)
-            budget = settings.get("_omg", {}).get("context_budget", {})
-            return {
-                "full_turns": budget.get("full_turns", defaults["full_turns"]),
-                "summarize_turns": budget.get("summarize_turns", defaults["summarize_turns"]),
-                "batch_size": budget.get("batch_size", defaults["batch_size"]),
-            }
-    except Exception:
-        pass
-    return defaults
-
-
-def _detect_model_id(data):
-    if isinstance(data, dict):
-        model = data.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 = data.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_compaction_threshold(data):
-    model_id = _detect_model_id(data)
-    if get_model_limits is not None and compaction_trigger is not None:
-        limits = get_model_limits(model_id)
-        trigger = int(compaction_trigger(model_id))
-    else:
-        limits = {"class_label": "128k-class"}
-        trigger = 80_000
-    return {
-        "model_id": model_id,
-        "class_label": str(limits.get("class_label", "128k-class")),
-        "trigger_tokens": trigger,
-    }
-
-
-# ---------------------------------------------------------------------------
-# Main hook execution (side-effects — only runs when invoked as script)
-# ---------------------------------------------------------------------------
-
-def main():
-    try:
-        data = json.load(sys.stdin)
-    except (json.JSONDecodeError, EOFError):
-        sys.exit(0)
-
-    project_dir = _resolve_project_dir()
-    compaction_limits = _host_aware_compaction_threshold(data)
-    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
-    state_dir = resolve_state_dir(project_dir, "state", "")
-    snapshot_dir = os.path.join(state_dir, "snapshots", ts)
-
-    snapshot_files = [
-        resolve_state_file(project_dir, "state/profile.yaml", "profile.yaml"),
-        resolve_state_file(project_dir, "state/working-memory.md", "working-memory.md"),
-        resolve_state_file(project_dir, "state/_plan.md", "_plan.md"),
-        resolve_state_file(project_dir, "state/_checklist.md", "_checklist.md"),
-        resolve_state_file(project_dir, "state/quality-gate.json", "quality-gate.json"),
-        resolve_state_file(project_dir, "state/ledger/tool-ledger.jsonl", "ledger/tool-ledger.jsonl"),
-        resolve_state_file(project_dir, "state/ledger/failure-tracker.json", "ledger/failure-tracker.json"),
-        resolve_state_file(project_dir, "state/ralph-loop.json", "ralph-loop.json"),
-    ]
-    saved = []
-    for src in snapshot_files:
-        if os.path.exists(src):
-            dst = os.path.join(snapshot_dir, os.path.basename(src))
-            if snapshot_file(src, dst, MAX_SNAPSHOT_BYTES):
-                saved.append(os.path.basename(src))
-
-    summary_files = {
-        "profile": resolve_state_file(project_dir, "state/profile.yaml", "profile.yaml"),
-        "working_memory": resolve_state_file(project_dir, "state/working-memory.md", "working-memory.md"),
-        "plan": resolve_state_file(project_dir, "state/_plan.md", "_plan.md"),
-        "checklist": resolve_state_file(project_dir, "state/_checklist.md", "_checklist.md"),
-        "tracker": resolve_state_file(project_dir, "state/ledger/failure-tracker.json", "ledger/failure-tracker.json"),
-        "ralph_loop": resolve_state_file(project_dir, "state/ralph-loop.json", "ralph-loop.json"),
-    }
-    cached = read_cache(list(summary_files.values()))
-
-    profile = first_lines(cached.get(summary_files["profile"]), 20)
-    wm = first_lines(cached.get(summary_files["working_memory"]), 15)
-    plan = first_lines(cached.get(summary_files["plan"]), 10)
-    checklist = first_lines(cached.get(summary_files["checklist"]), 50)
-    tracker = cached.get(summary_files["tracker"])
-    ralph_loop = cached.get(summary_files["ralph_loop"])
-
-    parts = [
-        f"# Handoff -- {datetime.now().strftime('%Y-%m-%d %H:%M')}",
-        "Auto-generated before context compaction.",
-    ]
-    model_label = compaction_limits["model_id"] or "unknown"
-    parts.append(
-        "## Compaction Budget\n"
-        f"Model: {model_label} ({compaction_limits['class_label']})\n"
-        f"Trigger: {compaction_limits['trigger_tokens']} tokens"
-    )
-    if profile:
-        parts.append("<!-- section: working-state -->")
-        parts.append("## Project\n" + profile)
-    if wm:
-        parts.append("## Working State\n" + wm)
-    if plan:
-        parts.append("## Plan\n" + plan)
-    if checklist:
-        lines = checklist.split("\n")
-        done = sum(1 for l in lines if "[x]" in l.lower())
-        total = sum(1 for l in lines if l.strip().startswith(("[", "- [")))
-        pending = [l.strip() for l in lines if "[ ]" in l][:3]
-        parts.append("<!-- section: progress -->")
-        parts.append(f"## Progress: {done}/{total}")
-        if pending:
-            parts.append("Next:\n" + "\n".join(pending))
-    if tracker:
-        try:
-            t = json.loads(tracker)
-            active = {k: v for k, v in t.items() if isinstance(v, dict) and v.get("count", 0) >= 2}
-            if active:
-                warns = [f"- {k}: {v['count']}x" for k, v in list(active.items())[:5]]
-                parts.append("## Failed Approaches\n" + "\n".join(warns))
-        except Exception:
-            pass
-    if ralph_loop:
-        try:
-            rl = json.loads(ralph_loop)
-            if rl.get("active"):
-                rl_iter = rl.get("iteration", 0)
-                rl_max = rl.get("max_iterations", 50)
-                rl_goal = rl.get("original_prompt", "")[:80]
-                parts.append(f"## Ralph Loop\nIteration: {rl_iter}/{rl_max} | Goal: {rl_goal}")
-        except Exception:
-            pass
-
-    try:
-        diff_names = subprocess.run(
-            ["git", "diff", "--name-only"],
-            capture_output=True,
-            text=True,
-            timeout=GIT_DIFF_TIMEOUT_SEC,
-            cwd=project_dir,
-        )
-        changed = [l for l in diff_names.stdout.strip().split("\n") if l]
-        if changed:
-            parts.append("## Uncommitted\n" + "\n".join(f"- {x}" for x in changed[:5]))
-    except Exception:
-        pass
-
-    parts.append("## Resume Instructions")
-    parts.append("Read .omg/state/profile.yaml + this file.")
-    parts.append("\n---\n*Auto-generated before context compaction.*")
-    handoff = "\n\n".join(parts)
-    handoff_lines = handoff.split("\n")
-    if len(handoff_lines) > 120:
-        handoff = "\n".join(handoff_lines[:120]) + "\n\n(truncated)"
-
-    os.makedirs(state_dir, exist_ok=True)
-    with open(os.path.join(state_dir, "handoff.md"), "w", encoding="utf-8") as f:
-        f.write(handoff)
-
-    portable = handoff + "\n\nSelf-contained handoff for other platforms."
-    portable_lines = portable.split("\n")
-    if len(portable_lines) > 150:
-        portable = "\n".join(portable_lines[:150]) + "\n\n(truncated)"
-    with open(os.path.join(state_dir, "handoff-portable.md"), "w", encoding="utf-8") as f:
-        f.write(portable)
-
-    # Keep latest 5 snapshots
-    snapshots_parent = os.path.join(state_dir, "snapshots")
-    try:
-        if os.path.isdir(snapshots_parent):
-            entries = sorted(
-                [d for d in os.listdir(snapshots_parent) if os.path.isdir(os.path.join(snapshots_parent, d))]
-            )
-            for old in entries[:-5]:
-                shutil.rmtree(os.path.join(snapshots_parent, old), ignore_errors=True)
-    except Exception:
-        pass
-
-    print(f"[OMG pre-compact] Snapshotted {len(saved)} files -> {snapshot_dir}", file=sys.stderr)
-
-    # --- Protected context registry (feature-flagged under CONTEXT_MANAGER) ---
-    try:
-        if collect_protected_context is not None and get_feature_flag("CONTEXT_MANAGER", default=False):
-            protected = collect_protected_context(project_dir, context_text=handoff)
-            if protected:
-                json.dump({"additionalContext": protected}, sys.stdout)
-                print(f"[OMG pre-compact] Protected context injected ({len(protected)} chars)", file=sys.stderr)
-    except Exception:
-        pass  # crash isolation: never fail on protected context
-
-    # --- Hybrid summarization (feature-flagged under CONTEXT_MANAGER) ---
-    try:
-        if get_feature_flag("CONTEXT_MANAGER", default=False):
-            turns = data.get("conversation", [])
-            if turns:
-                config = _load_context_budget_config(project_dir)
-                result = _apply_hybrid_summarization(turns, config)
-                summaries = result.get("summaries", [])
-                discarded_raw = result.get("discarded_count", 0)
-                discarded_count = discarded_raw if isinstance(discarded_raw, int) else 0
-                full_turns = result.get("full_turns", [])
-                # Format as additionalContext supplement
-                summary_parts = []
-                if isinstance(summaries, list) and summaries:
-                    summary_parts.append("## Conversation Context (Hybrid Summary)")
-                    for s in summaries:
-                        if isinstance(s, str):
-                            summary_parts.append(s)
-                    if discarded_count > 0:
-                        summary_parts.append(
-                            f"({discarded_count} oldest turns discarded — see memory/handoff)"
-                        )
-                    _summary_text = "\n".join(summary_parts)
-                    # Output as JSON if no protected context was already output
-                    print(
-                        f"[OMG pre-compact] Hybrid summarization: "
-                        f"{len(full_turns) if isinstance(full_turns, list) else 0} full, "
-                        f"{len(summaries)} batches, "
-                        f"{discarded_count} discarded",
-                        file=sys.stderr,
-                    )
-    except Exception:
-        pass  # crash isolation: never fail on hybrid summarization
-
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/build/lib/hooks/pre-tool-inject.py

@@ -1,98 +0,0 @@
-#!/usr/bin/env python3
-"""PreToolUse Hook — Injects plan reminder before each tool call.
-
-Inspired by planning-with-files: forces re-read of plan on every tool call.
-OMG version: lighter — checklist-aware, tool-filtered, max 200 chars.
-Only injects for mutation tools (Write/Edit/Bash), not read-only tools.
-"""
-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, _resolve_project_dir
-from state_migration import resolve_state_file
-
-setup_crash_handler("pre-tool-inject")
-
-MAX_INJECTION = 200  # Total injection budget (chars)
-
-# Read-only tools that don't need plan reminders
-READ_ONLY_TOOLS = {
-    'Read', 'Glob', 'Grep', 'LS', 'NotebookRead', 'WebFetch', 'WebSearch',
-    'TodoRead', 'mcp__filesystem__read_file', 'mcp__filesystem__list_directory',
-}
-
-
-def should_inject(tool_name):
-    """Return True if this tool call should get a plan reminder."""
-    if not tool_name:
-        return True  # unknown tool → inject (safe default)
-    return tool_name not in READ_ONLY_TOOLS
-
-
-def get_checklist_progress(checklist_path):
-    """Return (done, total, first_pending) from checklist file."""
-    if not os.path.exists(checklist_path):
-        return None, None, None
-    try:
-        with open(checklist_path, "r", encoding="utf-8", errors="ignore") as f:
-            lines = f.readlines()
-        total = sum(1 for l in lines if re.search(r'^\s*-\s*\[[ x!]\]', l))
-        done = sum(1 for l in lines if re.search(r'^\s*-\s*\[x\]', l, re.IGNORECASE))
-        # Find first pending item text
-        first_pending = None
-        for l in lines:
-            if re.search(r'^\s*-\s*\[ \]', l):
-                first_pending = re.sub(r'^\s*-\s*\[ \]\s*', '', l).strip()[:50]
-                break
-        return done, total, first_pending
-    except OSError:
-        return None, None, None
-
-
-data = json_input()
-
-if not get_feature_flag("planning_enforcement"):
-    sys.exit(0)
-
-# Tool filtering: skip injection for read-only tools
-tool_name = data.get("tool_name") if isinstance(data, dict) else None
-if not should_inject(tool_name):
-    sys.exit(0)
-
-project_dir = _resolve_project_dir()
-
-# Try to find _plan.md
-plan_path = resolve_state_file(project_dir, "state/_plan.md", "_plan.md")
-
-if not os.path.exists(plan_path):
-    sys.exit(0)
-
-try:
-    # Check for checklist progress
-    checklist_path = resolve_state_file(project_dir, "state/_checklist.md", "_checklist.md")
-    done, total, first_pending = get_checklist_progress(checklist_path)
-
-    if total is not None and total > 0:
-        # Checklist-aware format
-        reminder = f"{done}/{total} done"
-        if first_pending:
-            reminder += f" | Next: {first_pending}"
-        injection = f"@plan-reminder: {reminder}"[:MAX_INJECTION]
-    else:
-        # Fallback: first 15 lines of plan
-        with open(plan_path, "r", encoding="utf-8", errors="ignore") as f:
-            lines = f.readlines()[:15]
-        head = "".join(lines)[:MAX_INJECTION]
-        injection = f"@plan-reminder: {head}"[:MAX_INJECTION]
-
-    json.dump({"contextInjection": injection}, sys.stdout)
-except Exception:
-    pass  # Graceful degradation
-
-sys.exit(0)