@trac3er/oh-my-god 2.2.2 → 2.3.0

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

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

package/build/lib/hooks/instructions-loaded.py

@@ -1,26 +0,0 @@
-#!/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/build/lib/hooks/intentgate-keyword-detector.py

@@ -1,200 +0,0 @@
-#!/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/build/lib/hooks/magic-keyword-router.py

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