@ekkos/cli 1.2.18 → 1.3.0

package/templates/hooks/stop.sh

@@ -1,382 +0,0 @@
-#!/bin/bash
-# ═══════════════════════════════════════════════════════════════════════════
-# ekkOS_ Hook: Stop - Captures turns to BOTH Working (Redis) and Episodic (Supabase)
-# NO jq dependency - uses Node.js for all JSON parsing
-# ═══════════════════════════════════════════════════════════════════════════
-# This hook captures every turn to:
-# 1. Working Sessions (Redis) - Fast hot cache for /continue
-# 2. Episodic Memory (Supabase) - Permanent cold storage
-#
-# NO compliance checking - skills handle that
-# NO PatternGuard validation - skills handle that
-# NO verbose output - just capture silently
-# ═══════════════════════════════════════════════════════════════════════════
-
-set +e
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(dirname "$(dirname "$SCRIPT_DIR")")"
-STATE_DIR="$PROJECT_ROOT/.claude/state"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# PROXY MODE DETECTION
-# ═══════════════════════════════════════════════════════════════════════════
-PROXY_MODE=false
-if [[ "$ANTHROPIC_BASE_URL" == *"proxy.ekkos.dev"* ]]; then
-  PROXY_MODE=true
-fi
-
-mkdir -p "$STATE_DIR" 2>/dev/null
-
-# ═══════════════════════════════════════════════════════════════════════════
-# CONFIG PATHS - No jq dependency (v1.2 spec)
-# Session words live in ~/.ekkos/ so they work in ANY project
-# ═══════════════════════════════════════════════════════════════════════════
-EKKOS_CONFIG_DIR="${EKKOS_CONFIG_DIR:-$HOME/.ekkos}"
-SESSION_WORDS_JSON="$EKKOS_CONFIG_DIR/session-words.json"
-SESSION_WORDS_DEFAULT="$EKKOS_CONFIG_DIR/.defaults/session-words.json"
-JSON_PARSE_HELPER="$EKKOS_CONFIG_DIR/.helpers/json-parse.cjs"
-
-INPUT=$(cat)
-
-# JSON parsing helper (no jq)
-parse_json_value() {
-    local json="$1"
-    local path="$2"
-    echo "$json" | node -e "
-const data = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8') || '{}');
-const path = '$path'.replace(/^\./,'').split('.').filter(Boolean);
-let result = data;
-for (const p of path) {
-    if (result === undefined || result === null) { result = undefined; break; }
-    result = result[p];
-}
-if (result !== undefined && result !== null) console.log(result);
-" 2>/dev/null || echo ""
-}
-
-RAW_SESSION_ID=$(parse_json_value "$INPUT" '.session_id')
-[ -z "$RAW_SESSION_ID" ] && RAW_SESSION_ID="unknown"
-TRANSCRIPT_PATH=$(parse_json_value "$INPUT" '.transcript_path')
-MODEL_USED=$(parse_json_value "$INPUT" '.model')
-[ -z "$MODEL_USED" ] && MODEL_USED="claude-sonnet-4-5"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# PROXY MODE: Slim hook path (local cleanup only)
-# ═══════════════════════════════════════════════════════════════════════════
-if [ "$PROXY_MODE" = "true" ]; then
-  rm -f "$STATE_DIR/hook-state.json" "$HOME/.claude/state/hook-state.json" 2>/dev/null || true
-  exit 0
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Session ID
-# ═══════════════════════════════════════════════════════════════════════════
-SESSION_ID="$RAW_SESSION_ID"
-
-if [ -z "$SESSION_ID" ] || [ "$SESSION_ID" = "unknown" ] || [ "$SESSION_ID" = "null" ]; then
-  exit 0
-fi
-
-# Check if SESSION_ID is a UUID (8-4-4-4-12 format)
-UUID_REGEX='^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'
-IS_UUID=false
-if [[ "$SESSION_ID" =~ $UUID_REGEX ]]; then
-  IS_UUID=true
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# WORD-BASED SESSION NAMES - No jq, uses ~/.ekkos/ config (works in ANY project)
-# ═══════════════════════════════════════════════════════════════════════════
-declare -a ADJECTIVES
-declare -a NOUNS
-declare -a VERBS
-SESSION_WORDS_LOADED=false
-
-load_session_words() {
-    if [ "$SESSION_WORDS_LOADED" = "true" ]; then return 0; fi
-
-    local words_file="$SESSION_WORDS_JSON"
-    [ ! -f "$words_file" ] && words_file="$SESSION_WORDS_DEFAULT"
-
-    if [ ! -f "$words_file" ] || [ ! -f "$JSON_PARSE_HELPER" ]; then
-        ADJECTIVES=("unknown"); NOUNS=("session"); VERBS=("starts")
-        return 1
-    fi
-
-    if command -v node &>/dev/null; then
-        if [ "${BASH_VERSINFO[0]}" -ge 4 ]; then
-            readarray -t ADJECTIVES < <(node "$JSON_PARSE_HELPER" "$words_file" '.adjectives' 2>/dev/null)
-            readarray -t NOUNS < <(node "$JSON_PARSE_HELPER" "$words_file" '.nouns' 2>/dev/null)
-            readarray -t VERBS < <(node "$JSON_PARSE_HELPER" "$words_file" '.verbs' 2>/dev/null)
-        else
-            local i=0
-            while IFS= read -r line; do ADJECTIVES[i]="$line"; ((i++)); done < <(node "$JSON_PARSE_HELPER" "$words_file" '.adjectives' 2>/dev/null)
-            i=0
-            while IFS= read -r line; do NOUNS[i]="$line"; ((i++)); done < <(node "$JSON_PARSE_HELPER" "$words_file" '.nouns' 2>/dev/null)
-            i=0
-            while IFS= read -r line; do VERBS[i]="$line"; ((i++)); done < <(node "$JSON_PARSE_HELPER" "$words_file" '.verbs' 2>/dev/null)
-        fi
-        [ ${#ADJECTIVES[@]} -eq 0 ] && ADJECTIVES=("unknown")
-        [ ${#NOUNS[@]} -eq 0 ] && NOUNS=("session")
-        [ ${#VERBS[@]} -eq 0 ] && VERBS=("starts")
-        SESSION_WORDS_LOADED=true
-        return 0
-    fi
-    ADJECTIVES=("unknown"); NOUNS=("session"); VERBS=("starts")
-    return 1
-}
-
-uuid_to_words() {
-    local uuid="$1"
-    load_session_words
-
-    local hex="${uuid//-/}"
-    hex="${hex:0:12}"
-    [[ ! "$hex" =~ ^[0-9a-fA-F]+$ ]] && echo "unknown-session-starts" && return
-
-    local adj_seed=$((16#${hex:0:4}))
-    local noun_seed=$((16#${hex:4:4}))
-    local verb_seed=$((16#${hex:8:4}))
-    local adj_idx=$((adj_seed % ${#ADJECTIVES[@]}))
-    local noun_idx=$((noun_seed % ${#NOUNS[@]}))
-    local verb_idx=$((verb_seed % ${#VERBS[@]}))
-    echo "${ADJECTIVES[$adj_idx]}-${NOUNS[$noun_idx]}-${VERBS[$verb_idx]}"
-}
-
-if [ "$IS_UUID" = true ]; then
-    SESSION_NAME=$(uuid_to_words "$SESSION_ID")
-else
-    SESSION_NAME="$SESSION_ID"
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Turn Number - read from turn file written by user-prompt-submit.sh
-# ═══════════════════════════════════════════════════════════════════════════
-TURN_FILE="$STATE_DIR/sessions/${SESSION_ID}.turn"
-mkdir -p "$STATE_DIR/sessions" 2>/dev/null
-TURN_NUMBER=1
-[ -f "$TURN_FILE" ] && TURN_NUMBER=$(cat "$TURN_FILE" 2>/dev/null || echo "1")
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Load auth - No jq
-# ═══════════════════════════════════════════════════════════════════════════
-EKKOS_CONFIG="$HOME/.ekkos/config.json"
-AUTH_TOKEN=""
-USER_ID=""
-
-if [ -f "$EKKOS_CONFIG" ] && [ -f "$JSON_PARSE_HELPER" ]; then
-    AUTH_TOKEN=$(node "$JSON_PARSE_HELPER" "$EKKOS_CONFIG" '.hookApiKey' 2>/dev/null || echo "")
-    [ -z "$AUTH_TOKEN" ] && AUTH_TOKEN=$(node "$JSON_PARSE_HELPER" "$EKKOS_CONFIG" '.apiKey' 2>/dev/null || echo "")
-    USER_ID=$(node "$JSON_PARSE_HELPER" "$EKKOS_CONFIG" '.userId' 2>/dev/null || echo "")
-fi
-
-if [ -z "$AUTH_TOKEN" ] && [ -f "$PROJECT_ROOT/.env.local" ]; then
-    AUTH_TOKEN=$(grep -E "^SUPABASE_SECRET_KEY=" "$PROJECT_ROOT/.env.local" | cut -d'=' -f2- | tr -d '"' | tr -d "'" | tr -d '\r')
-fi
-
-[ -z "$AUTH_TOKEN" ] && exit 0
-
-MEMORY_API_URL="https://mcp.ekkos.dev"
-
-# Session binding removed — proxy now self-resolves _pending → word-based
-# names inline via uuidToSessionName(). No external bind call needed.
-
-# ═══════════════════════════════════════════════════════════════════════════
-# EVICTION: Handled by IPC (In-Place Progressive Compression) in the proxy.
-# No hook-side eviction needed — passthrough is default for cache stability.
-# ═══════════════════════════════════════════════════════════════════════════
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Check for interruption - No jq
-# ═══════════════════════════════════════════════════════════════════════════
-IS_INTERRUPTED=$(parse_json_value "$INPUT" '.interrupted')
-[ -z "$IS_INTERRUPTED" ] && IS_INTERRUPTED="false"
-STOP_REASON=$(parse_json_value "$INPUT" '.stop_reason')
-
-if [ "$IS_INTERRUPTED" = "true" ] || [ "$STOP_REASON" = "user_cancelled" ] || [ "$STOP_REASON" = "interrupted" ]; then
-  exit 0
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Extract conversation from transcript using Node (no jq)
-# ═══════════════════════════════════════════════════════════════════════════
-LAST_USER=""
-LAST_ASSISTANT=""
-FILE_CHANGES="[]"
-
-if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then
-    EXTRACTION=$(node -e "
-const fs = require('fs');
-const lines = fs.readFileSync('$TRANSCRIPT_PATH', 'utf8').split('\n').filter(Boolean);
-const entries = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
-
-let lastUser = '', lastUserTime = '';
-for (let i = entries.length - 1; i >= 0; i--) {
-    const e = entries[i];
-    if (e.type === 'user') {
-        const content = e.message?.content;
-        if (typeof content === 'string' && !content.startsWith('<')) {
-            lastUser = content; lastUserTime = e.timestamp || ''; break;
-        } else if (Array.isArray(content)) {
-            const textPart = content.find(c => c.type === 'text' && !c.text?.startsWith('<'));
-            if (textPart) { lastUser = textPart.text; lastUserTime = e.timestamp || ''; break; }
-        }
-    }
-}
-
-let lastAssistant = '';
-for (let i = entries.length - 1; i >= 0; i--) {
-    const e = entries[i];
-    if (e.type === 'assistant' && (!lastUserTime || e.timestamp >= lastUserTime)) {
-        const content = e.message?.content;
-        if (typeof content === 'string') { lastAssistant = content; break; }
-        else if (Array.isArray(content)) {
-            const parts = content.map(c => {
-                if (c.type === 'text') return c.text;
-                if (c.type === 'tool_use') return '[TOOL: ' + c.name + ']';
-                if (c.type === 'thinking') return '[THINKING]' + (c.thinking || c.text || '') + '[/THINKING]';
-                return '';
-            }).filter(Boolean);
-            lastAssistant = parts.join('\n'); break;
-        }
-    }
-}
-
-const fileChanges = [];
-entries.filter(e => e.type === 'assistant').forEach(e => {
-    const content = e.message?.content;
-    if (Array.isArray(content)) {
-        content.filter(c => c.type === 'tool_use' && ['Edit', 'Write', 'Read'].includes(c.name)).forEach(c => {
-            fileChanges.push({tool: c.name, path: c.input?.file_path || c.input?.path, action: c.name.toLowerCase()});
-        });
-    }
-});
-
-console.log(JSON.stringify({
-    user: lastUser,
-    assistant: lastAssistant.substring(0, 50000),
-    fileChanges: fileChanges.slice(0, 20)
-}));
-" 2>/dev/null || echo '{"user":"","assistant":"","fileChanges":[]}')
-
-    LAST_USER=$(echo "$EXTRACTION" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(d.user||'')" 2>/dev/null || echo "")
-    LAST_ASSISTANT=$(echo "$EXTRACTION" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(d.assistant||'')" 2>/dev/null || echo "")
-    FILE_CHANGES=$(echo "$EXTRACTION" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(JSON.stringify(d.fileChanges||[]))" 2>/dev/null || echo "[]")
-fi
-
-if [ -z "$LAST_USER" ] || [[ "$LAST_USER" == *"[Request interrupted"* ]]; then
-    exit 0
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Capture to BOTH Working Sessions (Redis) AND Episodic (Supabase) - No jq
-# ═══════════════════════════════════════════════════════════════════════════
-if [ -n "$LAST_USER" ] && [ -n "$LAST_ASSISTANT" ]; then
-  (
-    TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-
-    TOOLS_USED=$(echo "$FILE_CHANGES" | node -e "
-const d = JSON.parse(require('fs').readFileSync('/dev/stdin','utf8') || '[]');
-console.log(JSON.stringify([...new Set(d.map(f => f.tool).filter(Boolean))]));
-" 2>/dev/null || echo "[]")
-
-    FILES_REF=$(echo "$FILE_CHANGES" | node -e "
-const d = JSON.parse(require('fs').readFileSync('/dev/stdin','utf8') || '[]');
-console.log(JSON.stringify([...new Set(d.map(f => f.path).filter(Boolean))]));
-" 2>/dev/null || echo "[]")
-
-    # Token breakdown from tokenizer script
-    TOTAL_TOKENS=0
-    INPUT_TOKENS=0
-    CACHE_READ_TOKENS=0
-    CACHE_CREATION_TOKENS=0
-    TOKENIZER_SCRIPT="$SCRIPT_DIR/lib/count-tokens.cjs"
-    if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ] && [ -f "$TOKENIZER_SCRIPT" ]; then
-      TOKEN_JSON=$(node "$TOKENIZER_SCRIPT" "$TRANSCRIPT_PATH" --json 2>/dev/null || echo '{}')
-      TOTAL_TOKENS=$(echo "$TOKEN_JSON" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')||'{}');console.log(d.total_tokens||0)" 2>/dev/null || echo "0")
-      INPUT_TOKENS=$(echo "$TOKEN_JSON" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')||'{}');console.log(d.input_tokens||0)" 2>/dev/null || echo "0")
-      CACHE_READ_TOKENS=$(echo "$TOKEN_JSON" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')||'{}');console.log(d.cache_read_tokens||0)" 2>/dev/null || echo "0")
-      CACHE_CREATION_TOKENS=$(echo "$TOKEN_JSON" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')||'{}');console.log(d.cache_creation_tokens||0)" 2>/dev/null || echo "0")
-      [[ ! "$TOTAL_TOKENS" =~ ^[0-9]+$ ]] && TOTAL_TOKENS=0
-    fi
-
-    # 1. WORKING SESSIONS (Redis) - No jq payload building
-    WORKING_PAYLOAD=$(node -e "
-console.log(JSON.stringify({
-    session_name: process.argv[1],
-    turn_number: parseInt(process.argv[2]),
-    user_query: process.argv[3],
-    agent_response: process.argv[4].substring(0, 50000),
-    model: process.argv[5],
-    tools_used: JSON.parse(process.argv[6] || '[]'),
-    files_referenced: JSON.parse(process.argv[7] || '[]'),
-    total_context_tokens: parseInt(process.argv[8]) || 0,
-    token_breakdown: {
-        input_tokens: parseInt(process.argv[9]) || 0,
-        cache_read_tokens: parseInt(process.argv[10]) || 0,
-        cache_creation_tokens: parseInt(process.argv[11]) || 0
-    }
-}));
-" "$SESSION_NAME" "$TURN_NUMBER" "$LAST_USER" "$LAST_ASSISTANT" "$MODEL_USED" "$TOOLS_USED" "$FILES_REF" "$TOTAL_TOKENS" "$INPUT_TOKENS" "$CACHE_READ_TOKENS" "$CACHE_CREATION_TOKENS" 2>/dev/null)
-
-    if [ -n "$WORKING_PAYLOAD" ]; then
-      curl -s -X POST "$MEMORY_API_URL/api/v1/working/turn" \
-        -H "Authorization: Bearer $AUTH_TOKEN" \
-        -H "Content-Type: application/json" \
-        -d "$WORKING_PAYLOAD" \
-        --connect-timeout 3 \
-        --max-time 5 >/dev/null 2>&1 || true
-    fi
-
-    # 2. EPISODIC MEMORY (Supabase) - No jq payload building
-    EPISODIC_PAYLOAD=$(node -e "
-console.log(JSON.stringify({
-    user_query: process.argv[1],
-    assistant_response: process.argv[2],
-    session_id: process.argv[3],
-    user_id: process.argv[4] || 'system',
-    file_changes: JSON.parse(process.argv[5] || '[]'),
-    metadata: {
-        source: 'claude-code',
-        model_used: process.argv[6],
-        captured_at: process.argv[7],
-        turn_number: parseInt(process.argv[8]) || 1,
-        session_name: process.argv[9],
-        minimal_hook: true
-    }
-}));
-" "$LAST_USER" "$LAST_ASSISTANT" "$SESSION_ID" "${USER_ID:-system}" "$FILE_CHANGES" "$MODEL_USED" "$TIMESTAMP" "$TURN_NUMBER" "$SESSION_NAME" 2>/dev/null)
-
-    if [ -n "$EPISODIC_PAYLOAD" ]; then
-      curl -s -X POST "$MEMORY_API_URL/api/v1/memory/capture" \
-        -H "Authorization: Bearer $AUTH_TOKEN" \
-        -H "Content-Type: application/json" \
-        -d "$EPISODIC_PAYLOAD" \
-        --connect-timeout 3 \
-        --max-time 5 >/dev/null 2>&1 || true
-    fi
-  ) &
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Update local .ekkos/current-focus.md (if exists) - SILENT
-# ═══════════════════════════════════════════════════════════════════════════
-EKKOS_LOCAL_DIR="$PROJECT_ROOT/.ekkos"
-if [ -d "$EKKOS_LOCAL_DIR" ] && [ -n "$LAST_USER" ]; then
-  FOCUS_FILE="$EKKOS_LOCAL_DIR/current-focus.md"
-  TASK_SUMMARY="${LAST_USER:0:100}"
-  [ ${#LAST_USER} -gt 100 ] && TASK_SUMMARY="${TASK_SUMMARY}..."
-
-  cat > "$FOCUS_FILE" << EOF
----
-last_updated: $(date -u +%Y-%m-%dT%H:%M:%SZ)
-session_id: ${SESSION_ID}
----
-
-# Current Focus
-${TASK_SUMMARY}
-EOF
-fi
-
-exit 0