@rulemetric/hooks 0.7.3 → 0.7.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulemetric/hooks",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "publishConfig": {
     "access": "public"
   },

package/scripts/_config.sh

@@ -9,6 +9,17 @@
 # Env var RULEMETRIC_ORG_ID always wins over the file. The variable is
 # exported so child curl/jq invocations and downstream scripts can see it.
 
+# npm packages a small jq-compatible fallback beside these scripts. Make it
+# discoverable on hosts that do not have jq installed system-wide.
+if ! command -v jq >/dev/null 2>&1; then
+  _rulemetric_scripts_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  if [ -x "$_rulemetric_scripts_dir/jq" ]; then
+    PATH="$_rulemetric_scripts_dir:$PATH"
+    export PATH
+  fi
+  unset _rulemetric_scripts_dir
+fi
+
 _rulemetric_config_dir() {
   if [ -n "${RULEMETRIC_CONFIG_DIR:-}" ]; then
     printf '%s' "$RULEMETRIC_CONFIG_DIR"

package/scripts/_log.sh

@@ -3,6 +3,15 @@
 # Appends JSON lines to $TMPDIR/rulemetric/hook.log
 # Never fails — all writes guarded with || true
 
+if ! command -v jq >/dev/null 2>&1; then
+  _rulemetric_log_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  if [ -x "$_rulemetric_log_dir/jq" ]; then
+    PATH="$_rulemetric_log_dir:$PATH"
+    export PATH
+  fi
+  unset _rulemetric_log_dir
+fi
+
 _rulemetric_log() {
   local script="${1:-unknown}"
   local outcome="${2:-unknown}"

package/scripts/_normalize.sh

@@ -1,4 +1,13 @@
 #!/usr/bin/env bash
+
+if ! command -v jq >/dev/null 2>&1; then
+  _rulemetric_normalize_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  if [ -x "$_rulemetric_normalize_dir/jq" ]; then
+    PATH="$_rulemetric_normalize_dir:$PATH"
+    export PATH
+  fi
+  unset _rulemetric_normalize_dir
+fi
 # RuleMetric: Normalize hook input across AI coding tools
 # Detects Claude Code, VS Code Copilot, Copilot CLI, and Cursor input formats,
 # then exports canonical HOOK_* variables for use by other scripts.
@@ -53,6 +62,13 @@ _rulemetric_normalize() {
   if [ "${RULEMETRIC_HOOK_TOOL:-}" = "antigravity" ]; then
     HOOK_TOOL="antigravity"
     HOOK_SESSION_ID=$(echo "$input" | jq -r '.conversationId // empty' 2>/dev/null)
+    # The validation below only passes bare UUIDs — a non-UUID conversationId
+    # would be silently blanked, killing all Antigravity capture. Hash anything
+    # else into a stable synthetic ID (same defense as cursor/copilot_cli).
+    if [ -n "$HOOK_SESSION_ID" ] && \
+       ! echo "$HOOK_SESSION_ID" | grep -qiE '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'; then
+      HOOK_SESSION_ID="antigravity-$(_rulemetric_short_hash "$HOOK_SESSION_ID")"
+    fi
     HOOK_CWD=$(echo "$input" | jq -r '
       .workspacePaths[0] //
       .workspace_roots[0] //
@@ -75,9 +91,9 @@ _rulemetric_normalize() {
     local cwd
     cwd=$(echo "$input" | jq -r '.cwd // empty')
     if [ -n "$cwd" ]; then
-      HOOK_SESSION_ID="copilot-cli-$(printf '%s' "$cwd" | shasum -a 256 | cut -c1-16)"
+      HOOK_SESSION_ID="copilot-cli-$(_rulemetric_short_hash "$cwd")"
     else
-      HOOK_SESSION_ID="copilot-cli-$(printf '%s' "unknown" | shasum -a 256 | cut -c1-16)"
+      HOOK_SESSION_ID="copilot-cli-$(_rulemetric_short_hash "unknown")"
     fi
 
     HOOK_CWD="$cwd"
@@ -124,9 +140,9 @@ _rulemetric_normalize() {
     local conversation_id
     conversation_id=$(echo "$input" | jq -r '.conversation_id // empty')
     if [ -n "$conversation_id" ]; then
-      HOOK_SESSION_ID="cursor-$(printf '%s' "$conversation_id" | shasum -a 256 | cut -c1-16)"
+      HOOK_SESSION_ID="cursor-$(_rulemetric_short_hash "$conversation_id")"
     else
-      HOOK_SESSION_ID="cursor-$(printf '%s' "unknown" | shasum -a 256 | cut -c1-16)"
+      HOOK_SESSION_ID="cursor-$(_rulemetric_short_hash "unknown")"
     fi
 
     HOOK_CWD=$(echo "$input" | jq -r '.workspace_roots[0] // .cwd // empty')
@@ -191,9 +207,10 @@ _rulemetric_normalize() {
   fi
 
   # Validate HOOK_SESSION_ID format (prevent path traversal)
-  # Accepts: standard UUIDs (case-insensitive), copilot-cli-<hex>, and cursor-<hex> synthetic IDs
+  # Accepts: standard UUIDs (case-insensitive), plus copilot-cli-<hex>,
+  # cursor-<hex>, and antigravity-<hex> synthetic IDs
   if [ -n "$HOOK_SESSION_ID" ]; then
-    if ! echo "$HOOK_SESSION_ID" | grep -qiE '^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|copilot-cli-[0-9a-f]{1,64}|cursor-[0-9a-f]{1,64})$'; then
+    if ! echo "$HOOK_SESSION_ID" | grep -qiE '^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|copilot-cli-[0-9a-f]{1,64}|cursor-[0-9a-f]{1,64}|antigravity-[0-9a-f]{1,64})$'; then
       HOOK_SESSION_ID=""
     fi
   fi

package/scripts/assistant-response.sh

@@ -71,16 +71,28 @@ TOKEN_USAGE=$(jq -n \
     (if $cr  != "" then {cache_read_input_tokens: ($cr | tonumber)} else {} end) +
     (if $cw  != "" then {cache_creation_input_tokens: ($cw | tonumber)} else {} end)')
 
-# Increment per-session sequence (same locking pattern as post-tool-use)
+# Increment per-session sequence (same locking pattern as post-tool-use):
+# bounded wait + stale-lock break, so a hook killed mid-section doesn't leak a
+# lock dir that wedges every later event hook for the session.
 SEQ_FILE="$TEMP_DIR/$HOOK_SESSION_ID.seq"
 LOCK_DIR="$TEMP_DIR/$HOOK_SESSION_ID.seqlock"
-while ! mkdir "$LOCK_DIR" 2>/dev/null; do sleep 0.01; done
+LOCK_TRIES=0
+while ! mkdir "$LOCK_DIR" 2>/dev/null; do
+  sleep 0.01
+  LOCK_TRIES=$((LOCK_TRIES + 1))
+  if [ "$LOCK_TRIES" -ge 500 ]; then
+    { rmdir "$LOCK_DIR" 2>/dev/null || rm -rf "$LOCK_DIR" 2>/dev/null; } || true
+    mkdir "$LOCK_DIR" 2>/dev/null || true
+    break
+  fi
+done
 SEQ=1
 if [ -f "$SEQ_FILE" ]; then
   SEQ=$(( $(cat "$SEQ_FILE") + 1 ))
 fi
 echo "$SEQ" > "$SEQ_FILE"
-rmdir "$LOCK_DIR"
+# Non-fatal: after a stale-lock break two hooks can briefly share the lock.
+rmdir "$LOCK_DIR" 2>/dev/null || true
 
 # Truncate text payload defensively (8 KB cap matches what the addon caps
 # its captured snapshots at).

package/scripts/jq

@@ -216,6 +216,7 @@ def build_known_n_filter(filter_, vars_):
             "gitBranch": vars_.get("gitBranch", ""),
             "metadata": vars_.get("metadata", {}),
             "orgId": vars_.get("orgId"),
+            "runId": vars_.get("runId"),
         }
 
     if 'eventType: "tool_call"' in compact:

package/scripts/post-tool-use.sh

@@ -48,16 +48,33 @@ if ! _rulemetric_ensure_session "post-tool-use"; then
   exit 0
 fi
 
-# Increment sequence counter (atomic mkdir lock, works on macOS + Linux)
+# Increment sequence counter (atomic mkdir lock, works on macOS + Linux).
+# Bounded wait + stale-lock break (same pattern as _ensure-session.sh): a hook
+# killed mid-section (run.ts's 10s timeout) leaks the lock dir, and an
+# unbounded spin here would silently wedge every later event hook for the
+# session.
 SEQ_FILE="$TEMP_DIR/$HOOK_SESSION_ID.seq"
 LOCK_DIR="$TEMP_DIR/$HOOK_SESSION_ID.seqlock"
-while ! mkdir "$LOCK_DIR" 2>/dev/null; do sleep 0.01; done
+LOCK_TRIES=0
+while ! mkdir "$LOCK_DIR" 2>/dev/null; do
+  sleep 0.01
+  LOCK_TRIES=$((LOCK_TRIES + 1))
+  if [ "$LOCK_TRIES" -ge 500 ]; then
+    # Stale lock — force remove and take it
+    { rmdir "$LOCK_DIR" 2>/dev/null || rm -rf "$LOCK_DIR" 2>/dev/null; } || true
+    mkdir "$LOCK_DIR" 2>/dev/null || true
+    break
+  fi
+done
 SEQ=1
 if [ -f "$SEQ_FILE" ]; then
   SEQ=$(( $(cat "$SEQ_FILE") + 1 ))
 fi
 echo "$SEQ" > "$SEQ_FILE"
-rmdir "$LOCK_DIR"
+# Non-fatal: after a stale-lock break two hooks can briefly share the lock, so
+# the dir may already be gone. A failing rmdir here would trip the ERR trap and
+# drop the event we just sequenced.
+rmdir "$LOCK_DIR" 2>/dev/null || true
 
 # Build payload — toolInput/toolOutput as JSON objects
 PAYLOAD=$(jq -n \

package/scripts/session-end.sh

@@ -118,10 +118,14 @@ fi
   "$AUTH_HEADER" "{\"sessionId\":\"$RW_SESSION_ID\"}" "session-end-link" 8 > /dev/null 2>&1) &
 
 # ── Auto-enrich from local session-meta ──
-# For Claude Code: read local session-meta file
+# For Claude Code: read local session-meta file when present; nothing writes
+# that dir anymore, so when it's missing fall back to deriving enrichment
+# from the reimported events (claude_code enrichment was silently dead
+# without this — with_meta dropped to ~0 from April on).
 # For other tools: derive enrichment from stored session events via API
 if [ "$HOOK_TOOL" = "claude_code" ]; then
   SESSION_META_FILE="$HOME/.claude/usage-data/session-meta/$HOOK_SESSION_ID.json"
+  ENRICH_PAYLOAD=""
   if [ -f "$SESSION_META_FILE" ]; then
     # Build enrichment payload from local session-meta
     ENRICH_PAYLOAD=$(SESSION_META_FILE="$SESSION_META_FILE" python3 -c "
@@ -156,13 +160,17 @@ try:
 except:
     pass
 " 2>/dev/null)
+  fi
 
-    if [ -n "$ENRICH_PAYLOAD" ]; then
-      # Backgrounded retry-on-503 so a transient wedge doesn't drop enrichment
-      # (leaving insights stuck at the last-enriched session).
-      (_rulemetric_send PATCH "${RULEMETRIC_API_URL}/api/sessions/${RW_SESSION_ID}/enrich" \
-        "$AUTH_HEADER" "$ENRICH_PAYLOAD" "session-end-enrich" > /dev/null 2>&1) &
-    fi
+  if [ -n "$ENRICH_PAYLOAD" ]; then
+    # Backgrounded retry-on-503 so a transient wedge doesn't drop enrichment
+    # (leaving insights stuck at the last-enriched session).
+    (_rulemetric_send PATCH "${RULEMETRIC_API_URL}/api/sessions/${RW_SESSION_ID}/enrich" \
+      "$AUTH_HEADER" "$ENRICH_PAYLOAD" "session-end-enrich" > /dev/null 2>&1) &
+  else
+    # Meta file missing or unreadable — derive from the reimported events.
+    (_rulemetric_send POST "${RULEMETRIC_API_URL}/api/sessions/${RW_SESSION_ID}/derive-enrichment" \
+      "$AUTH_HEADER" '{}' "session-end-derive" 8 > /dev/null 2>&1) &
   fi
 else
   # Non-Claude tools: derive enrichment from stored session events
@@ -181,22 +189,30 @@ fi
 # ── Auto-generate recommendations (daily debounce) ──
 # Queue a recommendation job if one hasn't been generated today.
 # The worker picks it up and runs 7 Opus prompts (~$5-15 per run).
+# HOOK_CWD comes from the hook payload's cwd — JSON-encode it via jq; spliced
+# raw, a path with a quote/backslash 400s the enqueue silently.
 (curl -sf --noproxy '*' --max-time 4 -X POST "${RULEMETRIC_API_URL}/api/insights-jobs" \
   -H "$AUTH_HEADER" \
   -H "Content-Type: application/json" \
-  -d "{\"dedup\":\"daily\",\"projectPath\":\"${HOOK_CWD}\"}" > /dev/null 2>&1) &
+  -d "$(jq -nc --arg projectPath "$HOOK_CWD" '{dedup: "daily", projectPath: $projectPath}')" > /dev/null 2>&1) &
+
+# Clean up temp files. The lock DIRS (.seqlock/.sesslock/.ptlock) are removed
+# too — a hook killed mid-section leaks one, and a leaked lock outlives the
+# session it belonged to.
+_rulemetric_cleanup_session_temp() {
+  local key="$1"
+  [ -n "$key" ] || return 0
+  rm -f "$TEMP_DIR/$key" "$TEMP_DIR/$key.seq" "$TEMP_DIR/$key.ctxhash" 2>/dev/null || true
+  rm -rf "$TEMP_DIR/$key.seqlock" "$TEMP_DIR/$key.sesslock" "$TEMP_DIR/$key.ptlock" 2>/dev/null || true
+}
 
-# Clean up temp files
 for registry_file in "$TEMP_DIR"/*; do
   [ -f "$registry_file" ] || continue
   case "$registry_file" in
     *.log|*.seq|*.ctxhash|*.pid|*.lock) continue ;;
   esac
   if [ "$(sed -n '1p' "$registry_file" 2>/dev/null || true)" = "$RW_SESSION_ID" ]; then
-    rm -f "$registry_file" 2>/dev/null || true
-    rm -f "$registry_file.seq" 2>/dev/null || true
-    rm -f "$registry_file.ctxhash" 2>/dev/null || true
+    _rulemetric_cleanup_session_temp "$(basename "$registry_file")"
   fi
 done
-rm -f "$TEMP_DIR/$HOOK_SESSION_ID" 2>/dev/null || true
-rm -f "$TEMP_DIR/$HOOK_SESSION_ID.seq" 2>/dev/null || true
+_rulemetric_cleanup_session_temp "$HOOK_SESSION_ID"

package/scripts/user-prompt.sh

@@ -36,16 +36,33 @@ if ! _rulemetric_ensure_session "user-prompt"; then
   exit 0
 fi
 
-# Increment sequence counter (atomic mkdir lock, works on macOS + Linux)
+# Increment sequence counter (atomic mkdir lock, works on macOS + Linux).
+# Bounded wait + stale-lock break (same pattern as _ensure-session.sh): a hook
+# killed mid-section (run.ts's 10s timeout) leaks the lock dir, and an
+# unbounded spin here would silently wedge every later event hook for the
+# session.
 SEQ_FILE="$TEMP_DIR/$HOOK_SESSION_ID.seq"
 LOCK_DIR="$TEMP_DIR/$HOOK_SESSION_ID.seqlock"
-while ! mkdir "$LOCK_DIR" 2>/dev/null; do sleep 0.01; done
+LOCK_TRIES=0
+while ! mkdir "$LOCK_DIR" 2>/dev/null; do
+  sleep 0.01
+  LOCK_TRIES=$((LOCK_TRIES + 1))
+  if [ "$LOCK_TRIES" -ge 500 ]; then
+    # Stale lock — force remove and take it
+    rmdir "$LOCK_DIR" 2>/dev/null || rm -rf "$LOCK_DIR" 2>/dev/null
+    mkdir "$LOCK_DIR" 2>/dev/null || true
+    break
+  fi
+done
 SEQ=1
 if [ -f "$SEQ_FILE" ]; then
   SEQ=$(( $(cat "$SEQ_FILE") + 1 ))
 fi
 echo "$SEQ" > "$SEQ_FILE"
-rmdir "$LOCK_DIR"
+# Non-fatal: after a stale-lock break two hooks can briefly share the lock, so
+# the dir may already be gone. A failing rmdir here would trip the ERR trap and
+# drop the event we just sequenced.
+rmdir "$LOCK_DIR" 2>/dev/null || true
 
 # Fire-and-forget event POST, with bounded retry on a transient 503/429 so the
 # admission gate (db-wedge plan Phase 1) sheds load without dropping the event.
@@ -58,4 +75,3 @@ _rulemetric_post_event \
 _rulemetric_log "user-prompt" "success"
 
 # Context capture is now handled by the proxy sniffer (`rulemetric proxy start`).
-# File-based scanning via _context-scan.sh is available as a manual fallback.