@trac3r/oh-my-god 2.2.11

package/hooks/idle-detector.py

@@ -0,0 +1,97 @@
+#!/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)
+"""
+from __future__ import annotations
+
+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)

package/hooks/instructions-loaded.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+"""Claude InstructionsLoaded compatibility hook.
+
+This event currently has no OMG-side behavior, but the hook must exist so
+post-install command surfaces do not fail when Claude emits the event.
+"""
+from __future__ import annotations
+
+import json
+import sys
+
+
+def main() -> int:
+    try:
+        raw = sys.stdin.read()
+        if raw.strip():
+            json.loads(raw)
+    except Exception:
+        return 0
+
+    json.dump({}, sys.stdout)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/hooks/intentgate-keyword-detector.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+"""
+IntentGate Keyword Detection Hook — OMG v1.2
+
+UserPromptSubmit hook that detects magic keywords in user prompts,
+maps them to intents with confidence scoring, and injects a LEADER_HINT
+into the hook output for downstream routing. Detection only — no execution.
+
+Classification v1.2:
+  - Each detected intent includes a confidence score (0.0–1.0)
+  - Compound intent parsing: multiple keywords → multiple intents
+
+Confidence rules:
+  - Exact keyword match (standalone): 0.95
+  - Keyword embedded in context: 0.90
+  - Keyword in compound phrase (multi-intent): 0.85
+  - Multiple occurrences of same keyword: 0.98 (cap)
+
+Magic keywords:
+  - ultrawork, autopilot, ralph → execution modes
+  - plan this, tdd, search → task types
+  - stop, crazy → special directives
+"""
+import json
+import sys
+import os
+import re
+import time
+
+HOOKS_DIR = os.path.dirname(__file__)
+if HOOKS_DIR not in sys.path:
+    sys.path.insert(0, HOOKS_DIR)
+
+try:
+    from hooks._common import (
+        setup_crash_handler,
+        json_input,
+        get_feature_flag,
+        _resolve_project_dir,
+        check_performance_budget,
+        PRE_TOOL_INJECT_MAX_MS as pre_tool_inject_max_ms,
+    )
+except ImportError:
+    import importlib
+    _common = importlib.import_module("_common")
+    setup_crash_handler = _common.setup_crash_handler
+    json_input = _common.json_input
+    get_feature_flag = _common.get_feature_flag
+    _resolve_project_dir = _common._resolve_project_dir
+    check_performance_budget = _common.check_performance_budget
+    pre_tool_inject_max_ms = _common.PRE_TOOL_INJECT_MAX_MS
+
+setup_crash_handler("intentgate-keyword-detector", fail_closed=False)
+
+# ═══════════════════════════════════════════════════════════
+# KEYWORD → INTENT MAPPING
+# ═══════════════════════════════════════════════════════════
+KEYWORD_INTENT_MAP = {
+    "ultrawork": "INTENT_MAX_EFFORT",
+    "autopilot": "INTENT_AUTONOMOUS",
+    "ralph": "INTENT_LOOP",
+    "plan this": "INTENT_PLAN",
+    "tdd": "INTENT_TEST_DRIVEN",
+    "search": "INTENT_SEARCH",
+    "stop": "INTENT_STOP",
+    "crazy": "INTENT_CRAZY",
+    "auth": "INTENT_AUTH_SETUP",
+    "login": "INTENT_AUTH_SETUP",
+    "credentials": "INTENT_AUTH_SETUP",
+    "setup my credentials": "INTENT_AUTH_SETUP",
+    "setup credentials": "INTENT_AUTH_SETUP",
+    "remember my settings": "INTENT_PREFERENCE_MEMORY",
+    "remember settings": "INTENT_PREFERENCE_MEMORY",
+    "preferences": "INTENT_PREFERENCE_MEMORY",
+    "memory style": "INTENT_PREFERENCE_MEMORY",
+    "setup preferences": "INTENT_AMBIGUOUS_CONFIG",
+    "configure preferences": "INTENT_AMBIGUOUS_CONFIG",
+    "remember setup": "INTENT_AMBIGUOUS_CONFIG",
+}
+
+
+# ═══════════════════════════════════════════════════════════
+# CONFIDENCE SCORING ENGINE
+# ═══════════════════════════════════════════════════════════
+
+def _count_keyword_occurrences(keyword, prompt_lower):
+    """Count occurrences of keyword in prompt (respecting matching rules)."""
+    if " " in keyword:
+        # Multi-word: non-overlapping substring count
+        count = 0
+        start = 0
+        while True:
+            idx = prompt_lower.find(keyword, start)
+            if idx == -1:
+                break
+            count += 1
+            start = idx + len(keyword)
+        return count
+    else:
+        # Single-word: word boundary count
+        pattern = r'\b' + re.escape(keyword) + r'\b'
+        return len(re.findall(pattern, prompt_lower))
+
+
+def _compute_confidence(keyword, prompt_lower, occurrence_count, total_intents):
+    """Compute confidence score for a detected intent.
+
+    Rules (applied in priority order):
+      - Multiple occurrences of same keyword: 0.98 (capped)
+      - Keyword in compound phrase (multiple intents): 0.85
+      - Exact keyword match (standalone prompt): 0.95
+      - Keyword embedded in context signals: 0.90
+    """
+    # Multiple occurrences of same keyword → highest confidence (cap)
+    if occurrence_count > 1:
+        return 0.98
+
+    # Compound intent (multiple different keywords detected)
+    if total_intents > 1:
+        return 0.85
+
+    # Single intent, single occurrence
+    stripped = prompt_lower.strip()
+
+    # Exact/standalone match → high confidence
+    if stripped == keyword:
+        return 0.95
+
+    # Keyword embedded in surrounding context → slightly lower
+    return 0.90
+# ═══════════════════════════════════════════════════════════
+# FEATURE FLAG CHECK
+# ═══════════════════════════════════════════════════════════
+start_time = time.time()
+
+if not get_feature_flag("INTENTGATE", default=False):
+    # Feature disabled — return no-op JSON
+    json.dump({}, sys.stdout)
+    sys.exit(0)
+
+# ═══════════════════════════════════════════════════════════
+# INPUT PARSING
+# ═══════════════════════════════════════════════════════════
+data = json_input()
+
+prompt = data.get("tool_input", {}).get("user_message", "") or data.get("user_message", "")
+if not prompt:
+    json.dump({}, sys.stdout)
+    sys.exit(0)
+
+prompt_lower = prompt.lower().strip()
+
+# ═══════════════════════════════════════════════════════════
+# KEYWORD DETECTION (case-insensitive, multi-keyword, confidence scoring)
+# ═══════════════════════════════════════════════════════════
+
+# First pass: detect keywords with occurrence counts
+detected_raw = []
+
+for keyword, intent in KEYWORD_INTENT_MAP.items():
+    occurrences = _count_keyword_occurrences(keyword, prompt_lower)
+    if occurrences > 0:
+        detected_raw.append((keyword, intent, occurrences))
+
+# Second pass: compute confidence scores
+num_intents = len(detected_raw)
+detected_intents = []
+
+for keyword, intent, occurrences in detected_raw:
+    confidence = _compute_confidence(keyword, prompt_lower, occurrences, num_intents)
+    detected_intents.append({
+        "intent": intent,
+        "confidence": confidence,
+        "keyword": keyword,
+    })
+# ═══════════════════════════════════════════════════════════
+# OUTPUT CONSTRUCTION
+# ═══════════════════════════════════════════════════════════
+output = {}
+
+if detected_intents:
+    # Inject LEADER_HINT with detected intents and confidence scores
+    output["LEADER_HINT"] = {
+        "detected_intents": detected_intents,
+        "keyword_count": len(detected_intents),
+        "routing_enabled": True,
+        "classification_version": "1.2",
+    }
+
+# ═══════════════════════════════════════════════════════════
+# PERFORMANCE BUDGET CHECK
+# ═══════════════════════════════════════════════════════════
+elapsed_ms = (time.time() - start_time) * 1000
+check_performance_budget("intentgate-keyword-detector", elapsed_ms, pre_tool_inject_max_ms)
+
+# ═══════════════════════════════════════════════════════════
+# OUTPUT
+# ═══════════════════════════════════════════════════════════
+json.dump(output, sys.stdout)
+sys.exit(0)

package/hooks/magic-keyword-router.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""
+Magic Keyword Router — OMG v1.2
+
+PostToolUse hook that reads the LEADER_HINT produced by
+intentgate-keyword-detector, selects the appropriate agent based on intent,
+and writes a routing result to `.omg/state/routing_result.json`.
+
+Decision only — no subprocess calls or agent execution.
+
+Input sources (checked in priority order):
+  1. LEADER_HINT in stdin JSON (from hook pipeline)
+  2. `.omg/state/leader_hint.json` (persisted by future integrations)
+
+Feature flag: OMG_MAGIC_ROUTER_ENABLED (default off)
+"""
+import json
+import os
+import sys
+import time
+
+HOOKS_DIR = os.path.dirname(__file__)
+if HOOKS_DIR not in sys.path:
+    sys.path.insert(0, HOOKS_DIR)
+
+try:
+    from hooks._common import (
+        setup_crash_handler,
+        json_input,
+        get_feature_flag,
+        atomic_json_write,
+        get_project_dir,
+        check_performance_budget,
+        PRE_TOOL_INJECT_MAX_MS,
+    )
+except ImportError:
+    import importlib
+    _common = importlib.import_module("_common")
+    setup_crash_handler = _common.setup_crash_handler
+    json_input = _common.json_input
+    get_feature_flag = _common.get_feature_flag
+    atomic_json_write = _common.atomic_json_write
+    get_project_dir = _common.get_project_dir
+    check_performance_budget = _common.check_performance_budget
+    PRE_TOOL_INJECT_MAX_MS = _common.PRE_TOOL_INJECT_MAX_MS
+
+try:
+    from hooks._agent_registry import INTENT_ROUTING
+except ImportError:
+    _registry = importlib.import_module("_agent_registry")
+    INTENT_ROUTING = _registry.INTENT_ROUTING
+
+setup_crash_handler("magic-keyword-router", fail_closed=False)
+
+# ═══════════════════════════════════════════════════════════
+# CONSTANTS
+# ═══════════════════════════════════════════════════════════
+ROUTING_RESULT_PATH = ".omg/state/routing_result.json"
+LEADER_HINT_PATH = ".omg/state/leader_hint.json"
+
+
+# ═══════════════════════════════════════════════════════════
+# FEATURE FLAG CHECK
+# ═══════════════════════════════════════════════════════════
+start_time = time.time()
+
+if not get_feature_flag("MAGIC_ROUTER", default=False):
+    # Feature disabled — no-op
+    json.dump({}, sys.stdout)
+    sys.exit(0)
+
+# ═══════════════════════════════════════════════════════════
+# INPUT PARSING
+# ═══════════════════════════════════════════════════════════
+data = json_input()
+
+
+def _extract_leader_hint(hook_data):
+    """Extract LEADER_HINT from hook stdin data.
+
+    Checks multiple locations where the hint may appear:
+      - Top-level "LEADER_HINT" key
+      - Nested under "tool_output"
+      - Nested under "hookSpecificOutput"
+    """
+    if not isinstance(hook_data, dict):
+        return None
+    # Direct top-level
+    hint = hook_data.get("LEADER_HINT")
+    if hint:
+        return hint
+    # Nested in tool_output
+    tool_output = hook_data.get("tool_output", {})
+    if isinstance(tool_output, dict):
+        hint = tool_output.get("LEADER_HINT")
+        if hint:
+            return hint
+    # Nested in hookSpecificOutput
+    hso = hook_data.get("hookSpecificOutput", {})
+    if isinstance(hso, dict):
+        hint = hso.get("LEADER_HINT")
+        if hint:
+            return hint
+    return None
+
+
+def _read_leader_hint_file(project_dir):
+    """Read LEADER_HINT from persisted file (secondary source)."""
+    path = os.path.join(project_dir, LEADER_HINT_PATH)
+    if not os.path.exists(path):
+        return None
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        # File may contain {"LEADER_HINT": {...}} or the hint directly
+        if isinstance(data, dict):
+            return data.get("LEADER_HINT", data) if "detected_intents" not in data else data
+        return None
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def _resolve_routing(leader_hint):
+    """Given a LEADER_HINT dict, resolve the target agent.
+
+    Returns (target_agent, intent, confidence) tuple.
+    target_agent may be None (e.g., INTENT_STOP → halt).
+    """
+    detected = leader_hint.get("detected_intents", [])
+    if not detected:
+        return None, None, 0.0
+
+    # Pick first non-None routable intent (highest priority = first in list)
+    for intent_entry in detected:
+        intent_name = intent_entry.get("intent", "")
+        confidence = intent_entry.get("confidence", 0.0)
+        target = INTENT_ROUTING.get(intent_name)
+
+        # INTENT_STOP maps to None explicitly — that IS a valid routing result
+        if intent_name in INTENT_ROUTING:
+            return target, intent_name, confidence
+
+    # No known intent found
+    return None, None, 0.0
+
+
+# ═══════════════════════════════════════════════════════════
+# LEADER_HINT RESOLUTION (stdin preferred, file fallback)
+# ═══════════════════════════════════════════════════════════
+project_dir = get_project_dir()
+leader_hint = _extract_leader_hint(data)
+
+if leader_hint is None:
+    leader_hint = _read_leader_hint_file(project_dir)
+
+# ═══════════════════════════════════════════════════════════
+# ROUTING DECISION
+# ═══════════════════════════════════════════════════════════
+from datetime import datetime, timezone
+
+routing_result_path = os.path.join(project_dir, ROUTING_RESULT_PATH)
+ts = datetime.now(timezone.utc).isoformat()
+
+if leader_hint and leader_hint.get("detected_intents"):
+    target_agent, intent, confidence = _resolve_routing(leader_hint)
+    routing_result = {
+        "target_agent": target_agent,
+        "intent": intent,
+        "confidence": confidence,
+        "fallback": False,
+        "timestamp": ts,
+    }
+else:
+    # No LEADER_HINT → fallback
+    routing_result = {
+        "target_agent": None,
+        "intent": None,
+        "confidence": 0.0,
+        "fallback": True,
+        "timestamp": ts,
+    }
+
+atomic_json_write(routing_result_path, routing_result)
+
+# ═══════════════════════════════════════════════════════════
+# PERFORMANCE BUDGET CHECK
+# ═══════════════════════════════════════════════════════════
+elapsed_ms = (time.time() - start_time) * 1000
+check_performance_budget("magic-keyword-router", elapsed_ms, PRE_TOOL_INJECT_MAX_MS)
+
+# ═══════════════════════════════════════════════════════════
+# OUTPUT (no-op for PostToolUse — just exit clean)
+# ═══════════════════════════════════════════════════════════
+json.dump({}, sys.stdout)
+sys.exit(0)