@ekkos/cli 1.2.17 → 1.3.0

package/templates/hooks/assistant-response.sh

@@ -1,160 +0,0 @@
-#!/bin/bash
-# ═══════════════════════════════════════════════════════════════════════════
-# ekkOS_ Hook: AssistantResponse - Validates and enforces footer format
-# MANAGED BY ekkos-connect - DO NOT EDIT DIRECTLY
-# EKKOS_MANAGED=1
-# ═══════════════════════════════════════════════════════════════════════════
-# Runs AFTER assistant response, checks footer compliance
-# Per spec v1.2 Addendum: NO jq, NO hardcoded arrays
-# ═══════════════════════════════════════════════════════════════════════════
-
-set +e
-
-RESPONSE_FILE="$1"
-HOOK_ENV="$2"
-
-# Exit if no response file
-if [[ ! -f "$RESPONSE_FILE" ]]; then
-  exit 0
-fi
-
-# ═══════════════════════════════════════════════════════════════════════════
-# CONFIG PATHS - No hardcoded word arrays per spec v1.2 Addendum
-# ═══════════════════════════════════════════════════════════════════════════
-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"
-
-# Parse metadata from hook environment using Node (no jq)
-parse_hook_env() {
-    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 ""
-}
-
-SESSION_ID=$(parse_hook_env "$HOOK_ENV" '.sessionId')
-[ -z "$SESSION_ID" ] && SESSION_ID="unknown"
-
-MODEL=$(parse_hook_env "$HOOK_ENV" '.model')
-[ -z "$MODEL" ] && MODEL="Claude Code (Opus 4.5)"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Session name conversion - Uses external session-words.json (NO hardcoded arrays)
-# ═══════════════════════════════════════════════════════════════════════════
-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"
-    if [ ! -f "$words_file" ]; then
-        words_file="$SESSION_WORDS_DEFAULT"
-    fi
-
-    if [ ! -f "$words_file" ] || [ ! -f "$JSON_PARSE_HELPER" ]; then
-        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
-
-        if [ ${#ADJECTIVES[@]} -gt 0 ] && [ ${#NOUNS[@]} -gt 0 ] && [ ${#VERBS[@]} -gt 0 ]; then
-            SESSION_WORDS_LOADED=true
-            return 0
-        fi
-    fi
-    return 1
-}
-
-convert_uuid_to_name() {
-    local uuid="$1"
-
-    load_session_words || {
-        echo "unknown-session"
-        return
-    }
-
-    local hex="${uuid//-/}"
-    hex="${hex:0:12}"
-
-    if [[ ! "$hex" =~ ^[0-9a-fA-F]+$ ]]; then
-        echo "unknown-session"
-        return
-    fi
-
-    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]}"
-}
-
-SESSION_NAME=$(convert_uuid_to_name "$SESSION_ID")
-TIMESTAMP=$(date "+%Y-%m-%d %I:%M:%S %p %Z")
-
-# Required footer format
-REQUIRED_FOOTER="---
-$MODEL · 🧠 ekkOS_™ · $SESSION_NAME · 📅 $TIMESTAMP"
-
-# Check if response has correct footer
-RESPONSE_CONTENT=$(cat "$RESPONSE_FILE")
-LAST_LINE=$(echo "$RESPONSE_CONTENT" | tail -1)
-
-# Check if footer exists and is correct
-if [[ "$LAST_LINE" == *"ekkOS"* ]] && [[ "$LAST_LINE" == *"$SESSION_NAME"* ]]; then
-    # Footer exists - validate format
-    if [[ "$LAST_LINE" == *"$SESSION_NAME"* ]] && [[ "$LAST_LINE" == *"📅"* ]]; then
-        # Footer is correct
-        exit 0
-    else
-        # Footer exists but is malformed - replace it
-        RESPONSE_WITHOUT_FOOTER=$(echo "$RESPONSE_CONTENT" | head -n -2)
-        echo "$RESPONSE_WITHOUT_FOOTER" > "$RESPONSE_FILE"
-        echo "" >> "$RESPONSE_FILE"
-        echo "$REQUIRED_FOOTER" >> "$RESPONSE_FILE"
-    fi
-else
-    # Footer missing - append it
-    echo "" >> "$RESPONSE_FILE"
-    echo "$REQUIRED_FOOTER" >> "$RESPONSE_FILE"
-fi
-
-exit 0

package/templates/hooks/hooks.json

@@ -1,40 +0,0 @@
-{
-  "hooks": {
-    "SessionStart": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash .claude/hooks/session-start.sh",
-            "timeout": 5000
-          }
-        ]
-      }
-    ],
-    "UserPromptSubmit": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash .claude/hooks/user-prompt-submit.sh",
-            "timeout": 5000
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash .claude/hooks/stop.sh",
-            "timeout": 5000
-          }
-        ]
-      }
-    ]
-  }
-}

package/templates/hooks/lib/contract.sh

@@ -1,332 +0,0 @@
-#!/bin/bash
-# ═══════════════════════════════════════════════════════════════════════════
-# ekkOS_ Turn Contract Library
-#
-# Shared functions for Golden Loop compliance enforcement.
-# Used by BOTH Claude Code (.claude/) and Cursor (.cursor/) hooks.
-#
-# TURN CONTRACT: Evidence that retrieval occurred before answering.
-# This is the SINGLE SOURCE OF TRUTH for compliance auditing.
-# ═══════════════════════════════════════════════════════════════════════════
-
-# Get contract directory based on environment
-get_contract_dir() {
-  local source="${1:-claude-code}"
-  local project_root="${2:-$PROJECT_ROOT}"
-
-  if [ "$source" = "cursor" ]; then
-    echo "$project_root/.cursor/state/ekkos"
-  else
-    echo "$project_root/.claude/state/ekkos"
-  fi
-}
-
-# Generate stable hash of user prompt (for deduplication)
-generate_query_hash() {
-  local query="$1"
-  # Use md5 on macOS, md5sum on Linux
-  if command -v md5 >/dev/null 2>&1; then
-    echo -n "$query" | md5 | cut -c1-16
-  elif command -v md5sum >/dev/null 2>&1; then
-    echo -n "$query" | md5sum | cut -c1-16
-  else
-    # Fallback: simple hash using cksum
-    echo -n "$query" | cksum | cut -d' ' -f1
-  fi
-}
-
-# Write turn contract at RETRIEVAL time
-# This is the EVIDENCE that retrieval happened before answering
-write_turn_contract() {
-  local session_id="$1"
-  local retrieval_ok="$2"
-  local retrieval_source="$3"
-  local pattern_ids="$4"      # Comma-separated list
-  local directive_ids="$5"    # Comma-separated list
-  local query_hash="$6"
-  local project_root="${7:-$PROJECT_ROOT}"
-
-  local contract_dir
-  contract_dir=$(get_contract_dir "$retrieval_source" "$project_root")
-  mkdir -p "$contract_dir" 2>/dev/null || return 1
-
-  local contract_file="$contract_dir/turn-contract-${session_id}.json"
-  local timestamp
-  timestamp=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-
-  # Convert comma-separated IDs to JSON array
-  local pattern_array
-  local directive_array
-  if [ -n "$pattern_ids" ]; then
-    pattern_array=$(echo "$pattern_ids" | tr ',' '\n' | grep -v '^$' | jq -R . | jq -s .)
-  else
-    pattern_array="[]"
-  fi
-  if [ -n "$directive_ids" ]; then
-    directive_array=$(echo "$directive_ids" | tr ',' '\n' | grep -v '^$' | jq -R . | jq -s .)
-  else
-    directive_array="[]"
-  fi
-
-  # Write contract
-  cat > "$contract_file" << EOF
-{
-  "session_id": "$session_id",
-  "retrieval_ok": $retrieval_ok,
-  "retrieval_source": "$retrieval_source",
-  "retrieved_pattern_ids": $pattern_array,
-  "retrieved_directive_ids": $directive_array,
-  "timestamp": "$timestamp",
-  "query_hash": "$query_hash",
-  "ekkos_strict": ${EKKOS_STRICT:-1}
-}
-EOF
-
-  return 0
-}
-
-# Read turn contract
-read_turn_contract() {
-  local session_id="$1"
-  local retrieval_source="$2"
-  local project_root="${3:-$PROJECT_ROOT}"
-
-  local contract_dir
-  contract_dir=$(get_contract_dir "$retrieval_source" "$project_root")
-  local contract_file="$contract_dir/turn-contract-${session_id}.json"
-
-  if [ -f "$contract_file" ]; then
-    cat "$contract_file"
-    return 0
-  else
-    return 1
-  fi
-}
-
-# Extract field from contract JSON
-get_contract_field() {
-  local contract_json="$1"
-  local field="$2"
-
-  echo "$contract_json" | jq -r ".$field // \"\"" 2>/dev/null
-}
-
-# Get array field as comma-separated string
-get_contract_array() {
-  local contract_json="$1"
-  local field="$2"
-
-  echo "$contract_json" | jq -r ".$field // [] | join(\",\")" 2>/dev/null
-}
-
-# Cleanup turn contract (only after successful capture)
-cleanup_turn_contract() {
-  local session_id="$1"
-  local retrieval_source="$2"
-  local project_root="${3:-$PROJECT_ROOT}"
-
-  local contract_dir
-  contract_dir=$(get_contract_dir "$retrieval_source" "$project_root")
-  local contract_file="$contract_dir/turn-contract-${session_id}.json"
-
-  rm -f "$contract_file" 2>/dev/null
-}
-
-# Check if strict mode is enabled
-is_strict_mode() {
-  [ "${EKKOS_STRICT:-1}" = "1" ]  # DEFAULT: ON
-}
-
-# Generate strict mode blocker message for Claude Code
-get_strict_blocker_message() {
-  cat << 'EOF'
-════════════════════════════════════════════════════════════════════════════
-⛔ EKKOS_STRICT MODE: RETRIEVAL FAILED — DO NOT ANSWER
-
-ekkOS memory retrieval failed or was not authenticated.
-In STRICT mode, you MUST NOT answer technical questions without memory context.
-
-ACTION REQUIRED:
-1. Check if ekkOS is connected: Run `ekkOS: Connect` in VS Code
-2. Verify auth token exists: ~/.ekkos/config.json
-3. Retry the request after connecting
-
-DO NOT proceed with answering. The Golden Loop requires retrieval FIRST.
-════════════════════════════════════════════════════════════════════════════
-EOF
-}
-
-# Validate PatternGuard coverage (returns 0-100)
-# PORTABLE: Works on macOS without Perl regex (grep -P)
-calculate_pattern_guard_coverage() {
-  local assistant_response="$1"
-  local pattern_ids="$2"  # Comma-separated
-
-  # Count total patterns - more robust counting
-  local total_count=0
-  if [ -n "$pattern_ids" ]; then
-    total_count=$(echo "$pattern_ids" | tr ',' '\n' | grep -v '^$' | wc -l | tr -d ' ')
-  fi
-
-  if [ "$total_count" -eq 0 ]; then
-    echo "100"  # No patterns = 100% coverage by definition
-    return 0
-  fi
-
-  # Extract acknowledged IDs using portable awk (works on macOS and Linux)
-  local acknowledged_count=0
-
-  # Use awk to extract SELECT block and count IDs - PORTABLE approach
-  local select_count=0
-  select_count=$(echo "$assistant_response" | awk '
-    /\[ekkOS_SELECT\]/{in_block=1; next}
-    /\[\/ekkOS_SELECT\]/{in_block=0}
-    in_block && /id:/{count++}
-    END{print count+0}
-  ')
-  acknowledged_count=$((acknowledged_count + select_count))
-
-  # Use awk to extract SKIP block and count IDs
-  local skip_count=0
-  skip_count=$(echo "$assistant_response" | awk '
-    /\[ekkOS_SKIP\]/{in_block=1; next}
-    /\[\/ekkOS_SKIP\]/{in_block=0}
-    in_block && /id:/{count++}
-    END{print count+0}
-  ')
-  acknowledged_count=$((acknowledged_count + skip_count))
-
-  # Legacy: Check for [ekkOS_APPLY] markers (fallback)
-  if [ "$acknowledged_count" -eq 0 ]; then
-    local apply_count
-    apply_count=$(echo "$assistant_response" | grep -c '\[ekkOS_APPLY\]' 2>/dev/null || echo 0)
-    acknowledged_count=$((acknowledged_count + apply_count))
-  fi
-
-  # Calculate coverage percentage
-  local coverage=0
-  if [ "$total_count" -gt 0 ]; then
-    coverage=$((acknowledged_count * 100 / total_count))
-  fi
-
-  # Cap at 100%
-  if [ "$coverage" -gt 100 ]; then
-    coverage=100
-  fi
-
-  echo "$coverage"
-}
-
-# Check for ekkOS footer presence
-check_footer_present() {
-  local assistant_response="$1"
-
-  # Look for the mandatory footer format:
-  # 🧠 **ekkOS_™** · 📅 YYYY-MM-DD
-  # OR
-  # {IDE} ({Model}) · 🧠 **ekkOS_™** · 📅 {Timestamp}
-
-  if echo "$assistant_response" | grep -qE '🧠.*ekkOS.*📅.*[0-9]{4}-[0-9]{2}-[0-9]{2}'; then
-    echo "true"
-    return 0
-  else
-    echo "false"
-    return 1
-  fi
-}
-
-# Build compliance metadata for capture
-build_compliance_metadata() {
-  local retrieval_ok="$1"
-  local pattern_guard_coverage="$2"
-  local footer_present="$3"
-  local ekkos_strict="$4"
-  local retrieved_count="$5"
-
-  local pattern_guard_required="false"
-  if [ "$retrieved_count" -gt 0 ]; then
-    pattern_guard_required="true"
-  fi
-
-  cat << EOF
-{
-  "retrieval_ok": $retrieval_ok,
-  "pattern_guard_required": $pattern_guard_required,
-  "pattern_guard_coverage_pct": $pattern_guard_coverage,
-  "footer_present": $footer_present,
-  "ekkos_strict": $ekkos_strict,
-  "retrieved_count": $retrieved_count,
-  "compliance_version": "1.0"
-}
-EOF
-}
-
-# Determine if turn is compliant
-# ROBUST: Handles edge cases with non-numeric or empty values
-is_turn_compliant() {
-  local retrieval_ok="${1:-true}"
-  local pattern_guard_coverage="${2:-100}"
-  local footer_present="${3:-true}"
-  local pattern_count="${4:-0}"
-
-  # Sanitize numeric values (default to safe values)
-  pattern_guard_coverage=$(echo "$pattern_guard_coverage" | grep -oE '^[0-9]+$' || echo "100")
-  pattern_count=$(echo "$pattern_count" | grep -oE '^[0-9]+$' || echo "0")
-
-  # Retrieval must have succeeded
-  if [ "$retrieval_ok" != "true" ]; then
-    echo "false"
-    return 1
-  fi
-
-  # If patterns were retrieved, PatternGuard must be 100%
-  if [ "$pattern_count" -gt 0 ] && [ "$pattern_guard_coverage" -lt 100 ]; then
-    echo "false"
-    return 1
-  fi
-
-  # Footer must be present
-  if [ "$footer_present" != "true" ]; then
-    echo "false"
-    return 1
-  fi
-
-  echo "true"
-  return 0
-}
-
-# Generate violation reason
-get_violation_reason() {
-  local retrieval_ok="$1"
-  local pattern_guard_coverage="$2"
-  local footer_present="$3"
-  local pattern_count="$4"
-
-  local reasons=""
-
-  if [ "$retrieval_ok" != "true" ]; then
-    reasons="retrieval_failed"
-  fi
-
-  if [ "$pattern_count" -gt 0 ] && [ "$pattern_guard_coverage" -lt 100 ]; then
-    if [ -n "$reasons" ]; then
-      reasons="$reasons,pattern_guard_incomplete"
-    else
-      reasons="pattern_guard_incomplete"
-    fi
-  fi
-
-  if [ "$footer_present" != "true" ]; then
-    if [ -n "$reasons" ]; then
-      reasons="$reasons,footer_missing"
-    else
-      reasons="footer_missing"
-    fi
-  fi
-
-  if [ -z "$reasons" ]; then
-    reasons="none"
-  fi
-
-  echo "$reasons"
-}

package/templates/hooks/lib/count-tokens.cjs

@@ -1,86 +0,0 @@
-#!/usr/bin/env node
-/**
- * Token counter for Claude Code hooks
- * Extracts ACTUAL token data from Anthropic API usage field
- *
- * The transcript contains the real usage data from each API response:
- * - input_tokens: new tokens in this request
- * - cache_read_input_tokens: cached tokens from previous turns
- * - cache_creation_input_tokens: tokens added to cache
- *
- * Usage:
- *   node count-tokens.cjs <transcript.jsonl>          -> outputs total token count
- *   node count-tokens.cjs <transcript.jsonl> --json   -> outputs full breakdown as JSON
- */
-
-const fs = require('fs');
-
-const filePath = process.argv[2];
-const outputJson = process.argv.includes('--json');
-
-if (!filePath) {
-  console.error('Usage: count-tokens.cjs <transcript.jsonl> [--json]');
-  process.exit(1);
-}
-
-if (!fs.existsSync(filePath)) {
-  console.error(`[count-tokens] ERROR: File not found: ${filePath}`);
-  process.exit(1);
-}
-
-/**
- * Extract token breakdown from the most recent assistant message's usage field
- * This is the authoritative data from Anthropic's API
- */
-function getTokenBreakdown(filePath) {
-  const content = fs.readFileSync(filePath, 'utf-8');
-  const lines = content.trim().split('\n').filter(Boolean);
-
-  // Find the most recent assistant message with usage data
-  let latestUsage = null;
-
-  for (const line of lines) {
-    try {
-      const entry = JSON.parse(line);
-
-      if (entry.type === 'assistant' && entry.message?.usage) {
-        latestUsage = entry.message.usage;
-      }
-    } catch (e) {
-      continue;
-    }
-  }
-
-  if (!latestUsage) {
-    return {
-      input_tokens: 0,
-      cache_read_tokens: 0,
-      cache_creation_tokens: 0,
-      total_tokens: 0,
-      output_tokens: 0
-    };
-  }
-
-  const inputTokens = latestUsage.input_tokens || 0;
-  const cacheRead = latestUsage.cache_read_input_tokens || 0;
-  const cacheCreation = latestUsage.cache_creation_input_tokens || 0;
-  const outputTokens = latestUsage.output_tokens || 0;
-
-  return {
-    input_tokens: inputTokens,
-    cache_read_tokens: cacheRead,
-    cache_creation_tokens: cacheCreation,
-    total_tokens: inputTokens + cacheRead + cacheCreation,
-    output_tokens: outputTokens
-  };
-}
-
-const breakdown = getTokenBreakdown(filePath);
-
-if (outputJson) {
-  // Output full breakdown as JSON (for API)
-  console.log(JSON.stringify(breakdown));
-} else {
-  // Output just the total (backward compatible)
-  console.log(breakdown.total_tokens);
-}