@ekkos/cli 1.2.17 → 1.3.0

package/templates/hooks/lib/ekkos-reminders.sh

@@ -1,98 +0,0 @@
-#!/bin/bash
-# ═══════════════════════════════════════════════════════════════════════════
-# ekkOS Tool Usage Reminders - Inject proactive tool usage hints
-# ═══════════════════════════════════════════════════════════════════════════
-
-# Detect if user query suggests using specific ekkOS tools
-# Returns markdown reminders to inject into Claude's context
-
-get_ekkos_reminders() {
-  local query="$1"
-  local prev_response="$2"
-  local reminders=""
-
-  # Convert to lowercase for matching
-  query_lower=$(echo "$query" | tr '[:upper:]' '[:lower:]')
-  response_lower=$(echo "$prev_response" | tr '[:upper:]' '[:lower:]')
-
-  # ═══════════════════════════════════════════════════════════════════════════
-  # ekkOS_Search - Before answering technical questions
-  # ═══════════════════════════════════════════════════════════════════════════
-  if echo "$query_lower" | grep -qE "(how do|how to|what is|why|explain|security|authentication|database|rls|deployment|error|bug|fix)"; then
-    reminders+="🧠 **ekkOS_Search Required**: Search memory before answering technical questions\n"
-  fi
-
-  # ═══════════════════════════════════════════════════════════════════════════
-  # ekkOS_Forge - When fixing bugs or learning
-  # ═══════════════════════════════════════════════════════════════════════════
-  if echo "$response_lower" | grep -qE "(fixed|solved|resolved|bug|issue|error|migration|implemented|created|updated)"; then
-    reminders+="🔨 **ekkOS_Forge Recommended**: Forge pattern after fixing bugs or implementing solutions\n"
-  fi
-
-  # ═══════════════════════════════════════════════════════════════════════════
-  # ekkOS_Directive - User preferences
-  # ═══════════════════════════════════════════════════════════════════════════
-  if echo "$query_lower" | grep -qE "(always|never|dont|don't|prefer|avoid|should not|shouldn't)"; then
-    directive_type="PREFER"
-    if echo "$query_lower" | grep -qE "(always|must)"; then
-      directive_type="MUST"
-    elif echo "$query_lower" | grep -qE "(never|dont|don't|avoid|should not)"; then
-      directive_type="NEVER"
-    fi
-    reminders+="📋 **ekkOS_Directive Required**: User stated a preference - save as ${directive_type} directive\n"
-  fi
-
-  # ═══════════════════════════════════════════════════════════════════════════
-  # ekkOS_Conflict - Destructive operations
-  # ═══════════════════════════════════════════════════════════════════════════
-  if echo "$query_lower" | grep -qE "(delete|remove|drop|truncate|destroy|wipe)"; then
-    reminders+="⚠️  **ekkOS_Conflict Required**: Check for conflicts before destructive operations\n"
-  fi
-
-  # ═══════════════════════════════════════════════════════════════════════════
-  # ekkOS_Plan - Complex multi-step tasks
-  # ═══════════════════════════════════════════════════════════════════════════
-  if echo "$query_lower" | grep -qE "(implement|build|create.*feature|add.*functionality|refactor|migrate)"; then
-    reminders+="📝 **ekkOS_Plan Recommended**: Create structured plan for multi-step implementation\n"
-  fi
-
-  # ═══════════════════════════════════════════════════════════════════════════
-  # ekkOS_StoreSecret - Credentials shared
-  # ═══════════════════════════════════════════════════════════════════════════
-  if echo "$query_lower" | grep -qE "(api.?key|token|password|secret|credential|github.*key|openai.*key)"; then
-    reminders+="🔐 **ekkOS_StoreSecret Available**: Use to securely store credentials (AES-256-GCM)\n"
-  fi
-
-  # ═══════════════════════════════════════════════════════════════════════════
-  # ekkOS_Recall - Past conversations
-  # ═══════════════════════════════════════════════════════════════════════════
-  if echo "$query_lower" | grep -qE "(yesterday|last week|previously|we discussed|earlier|before)"; then
-    reminders+="🕐 **ekkOS_Recall Available**: Retrieve past conversations by time\n"
-  fi
-
-  # ═══════════════════════════════════════════════════════════════════════════
-  # ekkOS_Codebase - Project-specific search
-  # ═══════════════════════════════════════════════════════════════════════════
-  if echo "$query_lower" | grep -qE "(in this project|in our codebase|where is.*defined|find.*file)"; then
-    reminders+="📂 **ekkOS_Codebase Available**: Search project-specific memory\n"
-  fi
-
-  # ═══════════════════════════════════════════════════════════════════════════
-  # ekkOS_Export - Backup request
-  # ═══════════════════════════════════════════════════════════════════════════
-  if echo "$query_lower" | grep -qE "(export|backup|download|save.*memory|portable)"; then
-    reminders+="💾 **ekkOS_Export Available**: Export all patterns/directives as portable JSON\n"
-  fi
-
-  # ═══════════════════════════════════════════════════════════════════════════
-  # ekkOS_Summary - Show activity
-  # ═══════════════════════════════════════════════════════════════════════════
-  if echo "$query_lower" | grep -qE "(what did.*do|ekkos.*activity|memory.*stats|show.*patterns)"; then
-    reminders+="📊 **ekkOS_Summary Available**: Show recent ekkOS activity\n"
-  fi
-
-  echo "$reminders"
-}
-
-# Export function
-export -f get_ekkos_reminders

package/templates/hooks/lib/state.sh

@@ -1,210 +0,0 @@
-#!/bin/bash
-# ═══════════════════════════════════════════════════════════════════════════
-# ekkOS™ Hook State Management Library (Portable)
-# Shared state functions for coordinating between hooks
-# ═══════════════════════════════════════════════════════════════════════════
-
-# Get project root (where .claude directory lives)
-get_project_root() {
-  local script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-  echo "$(dirname "$(dirname "$script_dir")")"
-}
-
-PROJECT_ROOT=$(get_project_root)
-STATE_DIR="$PROJECT_ROOT/.claude/state"
-
-# Ensure state directory exists
-mkdir -p "$STATE_DIR"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# State File Management
-# ═══════════════════════════════════════════════════════════════════════════
-
-# Save patterns for session (with retrieval_token for verified tracking)
-save_patterns() {
-  local session_id="$1"
-  local patterns="$2"
-  local model_used="$3"
-  local retrieval_token="${4:-}"  # Optional retrieval_token for verified applications
-
-  local state_file="$STATE_DIR/patterns-${session_id}.json"
-
-  jq -n \
-    --argjson patterns "$patterns" \
-    --arg model "$model_used" \
-    --arg token "$retrieval_token" \
-    --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-    '{
-      patterns: $patterns,
-      model_used: $model,
-      retrieval_token: $token,
-      saved_at: $timestamp
-    }' > "$state_file"
-}
-
-# Get retrieval token from saved patterns
-get_retrieval_token() {
-  local session_id="$1"
-  local state_file="$STATE_DIR/patterns-${session_id}.json"
-
-  if [ -f "$state_file" ]; then
-    jq -r '.retrieval_token // ""' "$state_file" 2>/dev/null
-  else
-    echo ""
-  fi
-}
-
-# Load patterns for session
-load_patterns() {
-  local session_id="$1"
-  local state_file="$STATE_DIR/patterns-${session_id}.json"
-
-  if [ -f "$state_file" ]; then
-    cat "$state_file"
-  else
-    echo '{}'
-  fi
-}
-
-# Clear patterns for session (after capture)
-clear_patterns() {
-  local session_id="$1"
-  rm -f "$STATE_DIR/patterns-${session_id}.json"
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Conversation Context (for Golden Loop MEASURE phase)
-# ═══════════════════════════════════════════════════════════════════════════
-
-# Save current conversation context for pattern tracking
-# Called by user-prompt-submit.sh when new query is submitted
-save_conversation_context() {
-  local session_id="$1"
-  local user_query="$2"
-  local prev_response="$3"
-
-  local context_file="$STATE_DIR/conversation-${session_id}.json"
-
-  jq -n \
-    --arg query "$user_query" \
-    --arg response "$prev_response" \
-    --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-    '{
-      query: $query,
-      response: $response,
-      saved_at: $timestamp
-    }' > "$context_file" 2>/dev/null || true
-}
-
-# Load current conversation context
-# Called by post-tool-use.sh when tracking pattern applications
-load_conversation_context() {
-  local session_id="$1"
-  local context_file="$STATE_DIR/conversation-${session_id}.json"
-
-  if [ -f "$context_file" ]; then
-    cat "$context_file"
-  else
-    echo '{"query":"","response":""}'
-  fi
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Capture Deduplication
-# ═══════════════════════════════════════════════════════════════════════════
-
-# Generate hash for conversation turn
-generate_turn_hash() {
-  local user_query="$1"
-  local assistant_response="$2"
-
-  echo "${user_query}${assistant_response}" | md5sum | cut -d' ' -f1 2>/dev/null || \
-    echo "${user_query}${assistant_response}" | md5 2>/dev/null
-}
-
-# Check if turn was already captured
-was_turn_captured() {
-  local session_id="$1"
-  local turn_hash="$2"
-
-  local capture_log="$STATE_DIR/captures-${session_id}.log"
-
-  if [ -f "$capture_log" ]; then
-    grep -q "^${turn_hash}$" "$capture_log"
-    return $?
-  fi
-
-  return 1 # Not captured
-}
-
-# Mark turn as captured
-mark_turn_captured() {
-  local session_id="$1"
-  local turn_hash="$2"
-
-  local capture_log="$STATE_DIR/captures-${session_id}.log"
-
-  echo "$turn_hash" >> "$capture_log"
-
-  # Keep only last 100 hashes
-  if [ $(wc -l < "$capture_log" 2>/dev/null || echo 0) -gt 100 ]; then
-    tail -100 "$capture_log" > "${capture_log}.tmp"
-    mv "${capture_log}.tmp" "$capture_log"
-  fi
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Hook Coordination
-# ═══════════════════════════════════════════════════════════════════════════
-
-# Lock for preventing race conditions
-acquire_lock() {
-  local session_id="$1"
-  local lock_file="$STATE_DIR/lock-${session_id}.lock"
-  local timeout=5
-  local waited=0
-
-  while [ -f "$lock_file" ] && [ $waited -lt $timeout ]; do
-    sleep 0.1
-    waited=$((waited + 1))
-  done
-
-  if [ -f "$lock_file" ]; then
-    # Stale lock (older than 10 seconds)
-    local lock_age=$(($(date +%s) - $(stat -f %m "$lock_file" 2>/dev/null || stat -c %Y "$lock_file" 2>/dev/null || echo 0)))
-    if [ $lock_age -gt 10 ]; then
-      rm -f "$lock_file"
-    else
-      return 1 # Failed to acquire
-    fi
-  fi
-
-  # Acquire lock
-  echo $$ > "$lock_file"
-  return 0
-}
-
-# Release lock
-release_lock() {
-  local session_id="$1"
-  local lock_file="$STATE_DIR/lock-${session_id}.lock"
-
-  if [ -f "$lock_file" ] && [ "$(cat "$lock_file")" = "$$" ]; then
-    rm -f "$lock_file"
-  fi
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Cleanup
-# ═══════════════════════════════════════════════════════════════════════════
-
-# Clean up old state files
-cleanup_old_state() {
-  # Remove files older than 24 hours
-  find "$STATE_DIR" -name "*.json" -mtime +1 -delete 2>/dev/null || true
-  find "$STATE_DIR" -name "*.log" -mtime +1 -delete 2>/dev/null || true
-  find "$STATE_DIR" -name "*.lock" -mtime +1 -delete 2>/dev/null || true
-}
-
-# Cleanup on exit
-trap cleanup_old_state EXIT

package/templates/hooks/session-start.ps1

@@ -1,146 +0,0 @@
-# ═══════════════════════════════════════════════════════════════════════════
-# ekkOS_ Hook: SessionStart - Initialize session (Windows)
-# MANAGED BY ekkos-connect - DO NOT EDIT DIRECTLY
-# EKKOS_MANAGED=1
-# EKKOS_MANIFEST_SHA256=<computed-at-build>
-# EKKOS_TEMPLATE_VERSION=1.0.0
-#
-# Per ekkOS Onboarding Spec v1.2 FINAL + ADDENDUM:
-# - All persisted records MUST include: instanceId, sessionId, sessionName
-# - Uses EKKOS_INSTANCE_ID env var for multi-session isolation
-# ═══════════════════════════════════════════════════════════════════════════
-
-$ErrorActionPreference = "SilentlyContinue"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# CONFIG PATHS - No hardcoded word arrays per spec v1.2 Addendum
-# ═══════════════════════════════════════════════════════════════════════════
-$EkkosConfigDir = if ($env:EKKOS_CONFIG_DIR) { $env:EKKOS_CONFIG_DIR } else { "$env:USERPROFILE\.ekkos" }
-$SessionWordsJson = "$EkkosConfigDir\session-words.json"
-$SessionWordsDefault = "$EkkosConfigDir\.defaults\session-words.json"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# INSTANCE ID - Multi-session isolation per v1.2 ADDENDUM
-# ═══════════════════════════════════════════════════════════════════════════
-$EkkosInstanceId = if ($env:EKKOS_INSTANCE_ID) { $env:EKKOS_INSTANCE_ID } else { "default" }
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Load session words from JSON file - NO HARDCODED ARRAYS
-# ═══════════════════════════════════════════════════════════════════════════
-$script:SessionWords = $null
-
-function Load-SessionWords {
-    $wordsFile = $SessionWordsJson
-
-    if (-not (Test-Path $wordsFile)) {
-        $wordsFile = $SessionWordsDefault
-    }
-
-    if (-not (Test-Path $wordsFile)) {
-        return $null
-    }
-
-    try {
-        $script:SessionWords = Get-Content $wordsFile -Raw | ConvertFrom-Json
-    } catch {
-        return $null
-    }
-}
-
-function Convert-UuidToWords {
-    param([string]$uuid)
-
-    if (-not $script:SessionWords) {
-        Load-SessionWords
-    }
-
-    if (-not $script:SessionWords) {
-        return "unknown-session"
-    }
-
-    $adjectives = $script:SessionWords.adjectives
-    $nouns = $script:SessionWords.nouns
-    $verbs = $script:SessionWords.verbs
-
-    if (-not $adjectives -or -not $nouns -or -not $verbs) {
-        return "unknown-session"
-    }
-
-    if (-not $uuid -or $uuid -eq "unknown") { return "unknown-session" }
-
-    $clean = $uuid -replace "-", ""
-    if ($clean.Length -lt 12) { return "unknown-session" }
-
-    try {
-        $a = [Convert]::ToInt32($clean.Substring(0,4), 16) % $adjectives.Length
-        $n = [Convert]::ToInt32($clean.Substring(4,4), 16) % $nouns.Length
-        $an = [Convert]::ToInt32($clean.Substring(8,4), 16) % $verbs.Length
-
-        return "$($adjectives[$a])-$($nouns[$n])-$($verbs[$an])"
-    } catch {
-        return "unknown-session"
-    }
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# READ INPUT
-# ═══════════════════════════════════════════════════════════════════════════
-$inputJson = [Console]::In.ReadToEnd()
-
-try {
-    $input = $inputJson | ConvertFrom-Json
-    $sessionId = $input.session_id
-} catch {
-    $sessionId = "unknown"
-}
-
-$sessionName = Convert-UuidToWords $sessionId
-
-# ═══════════════════════════════════════════════════════════════════════════
-# INITIALIZE STATE DIRECTORY
-# ═══════════════════════════════════════════════════════════════════════════
-$stateDir = Join-Path $env:USERPROFILE ".claude\state"
-if (-not (Test-Path $stateDir)) {
-    New-Item -ItemType Directory -Path $stateDir -Force | Out-Null
-}
-
-# Reset turn counter for new session
-$stateFile = Join-Path $stateDir "hook-state.json"
-$state = @{
-    turn = 0
-    session_id = $sessionId
-    session_name = $sessionName
-    instance_id = $EkkosInstanceId
-    started_at = (Get-Date).ToString("o")
-} | ConvertTo-Json -Depth 10
-
-Set-Content -Path $stateFile -Value $state -Force
-
-# Save session ID for other hooks
-$sessionFile = Join-Path $stateDir "current-session.json"
-$sessionData = @{
-    session_id = $sessionId
-    session_name = $sessionName
-    instance_id = $EkkosInstanceId
-} | ConvertTo-Json -Depth 10
-
-Set-Content -Path $sessionFile -Value $sessionData -Force
-
-# ═══════════════════════════════════════════════════════════════════════════
-# LOCAL CACHE: Initialize session in Tier 0 cache
-# Per v1.2 ADDENDUM: Pass instanceId for namespacing
-# ═══════════════════════════════════════════════════════════════════════════
-$captureCmd = Get-Command "ekkos-capture" -ErrorAction SilentlyContinue
-if ($captureCmd -and $sessionId -ne "unknown") {
-    try {
-        # NEW format: ekkos-capture init <instance_id> <session_id> <session_name>
-        Start-Job -ScriptBlock {
-            param($instanceId, $sessId, $sessName)
-            try {
-                & ekkos-capture init $instanceId $sessId $sessName 2>&1 | Out-Null
-            } catch {}
-        } -ArgumentList $EkkosInstanceId, $sessionId, $sessionName | Out-Null
-    } catch {}
-}
-
-Write-Output "ekkOS session initialized"