@ekkos/cli 1.0.35 → 1.1.0

package/templates/hooks/assistant-response.ps1

@@ -1,160 +1,256 @@
-# ═══════════════════════════════════════════════════════════════════════════
-# 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
-# ═══════════════════════════════════════════════════════════════════════════
-
-$ErrorActionPreference = "SilentlyContinue"
-
-$RESPONSE_FILE = $args[0]
-$HOOK_ENV = $args[1]
-
-# Exit if no response file
-if (-not $RESPONSE_FILE -or -not (Test-Path $RESPONSE_FILE)) {
-    exit 0
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# CONFIG PATHS - No hardcoded word arrays per spec v1.2 Addendum
-# ═══════════════════════════════════════════════════════════════════════════
-$EkkosConfigDir = if ($env:EKKOS_CONFIG_DIR) { $env:EKKOS_CONFIG_DIR } else { Join-Path $env:USERPROFILE ".ekkos" }
-$SessionWordsJson = Join-Path $EkkosConfigDir "session-words.json"
-$SessionWordsDefault = Join-Path $EkkosConfigDir ".defaults\session-words.json"
-$JsonParseHelper = Join-Path $EkkosConfigDir ".helpers\json-parse.cjs"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Parse metadata from hook environment using Node (no jq)
-# ═══════════════════════════════════════════════════════════════════════════
-function Parse-HookEnv {
-    param(
-        [string]$Json,
-        [string]$Path
-    )
-    if (-not $Json) { return "" }
-    try {
-        $result = $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>$null
-        if ($result) { return $result.Trim() } else { return "" }
-    } catch {
-        return ""
-    }
-}
-
-$SESSION_ID = Parse-HookEnv $HOOK_ENV ".sessionId"
-if (-not $SESSION_ID) { $SESSION_ID = "unknown" }
-
-$MODEL = Parse-HookEnv $HOOK_ENV ".model"
-if (-not $MODEL) { $MODEL = "Claude Code (Opus 4.5)" }
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Session name conversion - Uses external session-words.json (NO hardcoded arrays)
-# ═══════════════════════════════════════════════════════════════════════════
-$script:ADJECTIVES = @()
-$script:NOUNS = @()
-$script:VERBS = @()
-$script:SESSION_WORDS_LOADED = $false
-
-function Load-SessionWords {
-    if ($script:SESSION_WORDS_LOADED) { return }
-
-    $wordsFile = $SessionWordsJson
-    if (-not (Test-Path $wordsFile)) {
-        $wordsFile = $SessionWordsDefault
-    }
-
-    if ((-not (Test-Path $wordsFile)) -or (-not (Test-Path $JsonParseHelper))) {
-        return
-    }
-
-    try {
-        $adjRaw = & node $JsonParseHelper $wordsFile ".adjectives" 2>$null
-        $nounRaw = & node $JsonParseHelper $wordsFile ".nouns" 2>$null
-        $verbRaw = & node $JsonParseHelper $wordsFile ".verbs" 2>$null
-
-        $script:ADJECTIVES = @()
-        $script:NOUNS = @()
-        $script:VERBS = @()
-
-        if ($adjRaw) { $script:ADJECTIVES = @($adjRaw -split "`n" | Where-Object { $_ }) }
-        if ($nounRaw) { $script:NOUNS = @($nounRaw -split "`n" | Where-Object { $_ }) }
-        if ($verbRaw) { $script:VERBS = @($verbRaw -split "`n" | Where-Object { $_ }) }
-
-        if ($script:ADJECTIVES.Count -gt 0 -and $script:NOUNS.Count -gt 0 -and $script:VERBS.Count -gt 0) {
-            $script:SESSION_WORDS_LOADED = $true
-        }
-    } catch {}
-}
-
-function Convert-UuidToName {
-    param([string]$uuid)
-
-    Load-SessionWords
-
-    if (-not $script:SESSION_WORDS_LOADED) {
-        return "unknown-session"
-    }
-
-    $hex = $uuid -replace "-", ""
-    $hex = $hex.Substring(0, [Math]::Min(12, $hex.Length))
-
-    if ($hex -notmatch '^[0-9a-fA-F]+$') {
-        return "unknown-session"
-    }
-
-    try {
-        $adjSeed = [Convert]::ToInt32($hex.Substring(0, 4), 16)
-        $nounSeed = [Convert]::ToInt32($hex.Substring(4, 4), 16)
-        $verbSeed = [Convert]::ToInt32($hex.Substring(8, 4), 16)
-
-        $adjIdx = $adjSeed % $script:ADJECTIVES.Count
-        $nounIdx = $nounSeed % $script:NOUNS.Count
-        $verbIdx = $verbSeed % $script:VERBS.Count
-
-        return "$($script:ADJECTIVES[$adjIdx])-$($script:NOUNS[$nounIdx])-$($script:VERBS[$verbIdx])"
-    } catch {
-        return "unknown-session"
-    }
-}
-
-$SESSION_NAME = Convert-UuidToName $SESSION_ID
-$TIMESTAMP = Get-Date -Format "yyyy-MM-dd hh:mm:ss tt K"
-
-# Required footer format
-$REQUIRED_FOOTER = "---`n$MODEL · ekkOS_ · $SESSION_NAME · $TIMESTAMP"
-
-# Check if response has correct footer
-$RESPONSE_CONTENT = Get-Content $RESPONSE_FILE -Raw
-$lines = $RESPONSE_CONTENT -split "`n"
-$LAST_LINE = ""
-if ($lines.Count -gt 0) {
-    $LAST_LINE = $lines[$lines.Count - 1].Trim()
-}
-
-# Check if footer exists and is correct
-if ($LAST_LINE -match "ekkOS" -and $LAST_LINE -match [regex]::Escape($SESSION_NAME)) {
-    # Footer exists - validate format
-    if ($LAST_LINE -match [regex]::Escape($SESSION_NAME) -and $LAST_LINE -match "📅") {
-        # Footer is correct
-        exit 0
-    } else {
-        # Footer exists but is malformed - replace it
-        $withoutFooter = ($lines | Select-Object -SkipLast 2) -join "`n"
-        Set-Content -Path $RESPONSE_FILE -Value "$withoutFooter`n`n$REQUIRED_FOOTER" -NoNewline -Force
-    }
-} else {
-    # Footer missing - append it
-    Add-Content -Path $RESPONSE_FILE -Value "`n`n$REQUIRED_FOOTER"
-}
-
-exit 0
+# ═══════════════════════════════════════════════════════════════════════════
+# ekkOS_ Hook: AssistantResponse - Process Claude's response (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" }
+$HooksEnabledJson = "$EkkosConfigDir\hooks-enabled.json"
+$HooksEnabledDefault = "$EkkosConfigDir\.defaults\hooks-enabled.json"
+$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" }
+
+# ═══════════════════════════════════════════════════════════════════════════
+# CHECK ENABLEMENT - Respect hooks-enabled.json
+# ═══════════════════════════════════════════════════════════════════════════
+function Test-HookEnabled {
+    param([string]$HookName)
+
+    $enabledFile = $HooksEnabledJson
+    if (-not (Test-Path $enabledFile)) {
+        $enabledFile = $HooksEnabledDefault
+    }
+
+    if (-not (Test-Path $enabledFile)) {
+        # No enablement file = all enabled by default
+        return $true
+    }
+
+    try {
+        $config = Get-Content $enabledFile -Raw | ConvertFrom-Json
+
+        # Check claude.enabled array
+        if ($config.claude -and $config.claude.enabled) {
+            $enabledHooks = $config.claude.enabled
+            if ($enabledHooks -contains $HookName -or $enabledHooks -contains "assistant-response") {
+                return $true
+            }
+            return $false
+        }
+
+        return $true  # Default to enabled if no config
+    } catch {
+        return $true  # Default to enabled on error
+    }
+}
+
+# Check if this hook is enabled
+if (-not (Test-HookEnabled "assistant-response")) {
+    exit 0
+}
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Load session words from JSON file - NO HARDCODED ARRAYS
+# ═══════════════════════════════════════════════════════════════════════════
+$script:SessionWords = $null
+
+function Load-SessionWords {
+    $wordsFile = $SessionWordsJson
+
+    # Fallback to managed defaults if user file missing/invalid
+    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
+    }
+}
+
+# ═══════════════════════════════════════════════════════════════════════════
+# SESSION NAME (UUID to words) - Uses external session-words.json
+# ═══════════════════════════════════════════════════════════════════════════
+function Convert-UuidToWords {
+    param([string]$uuid)
+
+    # Load session words if not already loaded
+    if (-not $script:SessionWords) {
+        Load-SessionWords
+    }
+
+    # Handle missing session words gracefully
+    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()
+if (-not $inputJson) { exit 0 }
+
+try {
+    $input = $inputJson | ConvertFrom-Json
+} catch {
+    exit 0
+}
+
+# Extract response content
+$assistantResponse = $input.response
+if (-not $assistantResponse) { $assistantResponse = $input.message }
+if (-not $assistantResponse) { $assistantResponse = $input.content }
+if (-not $assistantResponse) { exit 0 }
+
+# Get session ID
+$rawSessionId = $input.session_id
+if (-not $rawSessionId -or $rawSessionId -eq "null") { $rawSessionId = "unknown" }
+
+# Fallback: read session_id from saved state
+if ($rawSessionId -eq "unknown") {
+    $stateFile = Join-Path $env:USERPROFILE ".claude\state\current-session.json"
+    if (Test-Path $stateFile) {
+        try {
+            $state = Get-Content $stateFile -Raw | ConvertFrom-Json
+            $rawSessionId = $state.session_id
+        } catch {}
+    }
+}
+
+$sessionName = Convert-UuidToWords $rawSessionId
+
+# ═══════════════════════════════════════════════════════════════════════════
+# READ TURN STATE
+# ═══════════════════════════════════════════════════════════════════════════
+$stateFile = Join-Path $env:USERPROFILE ".claude\state\hook-state.json"
+$turn = 0
+
+if (Test-Path $stateFile) {
+    try {
+        $hookState = Get-Content $stateFile -Raw | ConvertFrom-Json
+        $turn = [int]$hookState.turn
+    } catch {
+        $turn = 0
+    }
+}
+
+# ═══════════════════════════════════════════════════════════════════════════
+# PATTERN TRACKING (detect [ekkOS_SELECT] blocks)
+# ═══════════════════════════════════════════════════════════════════════════
+$patternIds = @()
+if ($assistantResponse -match '\[ekkOS_SELECT\]') {
+    # Extract pattern IDs from SELECT blocks
+    $selectMatches = [regex]::Matches($assistantResponse, 'id:\s*([a-zA-Z0-9\-_]+)')
+    foreach ($match in $selectMatches) {
+        $patternIds += $match.Groups[1].Value
+    }
+}
+
+# ═══════════════════════════════════════════════════════════════════════════
+# LOCAL CACHE: Tier 0 capture (async, non-blocking)
+# Per v1.2 ADDENDUM: Pass instanceId for namespacing
+# ═══════════════════════════════════════════════════════════════════════════
+$captureCmd = Get-Command "ekkos-capture" -ErrorAction SilentlyContinue
+if ($captureCmd -and $rawSessionId -ne "unknown") {
+    try {
+        # NEW format: ekkos-capture response <instance_id> <session_id> <turn_id> <response> [tools] [files]
+        $responseBase64 = [Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($assistantResponse))
+        $toolsJson = "[]"
+        $filesJson = "[]"
+
+        # Extract tools used from response
+        $toolMatches = [regex]::Matches($assistantResponse, '\[TOOL:\s*([^\]]+)\]')
+        if ($toolMatches.Count -gt 0) {
+            $tools = $toolMatches | ForEach-Object { $_.Groups[1].Value } | Select-Object -Unique
+            $toolsJson = $tools | ConvertTo-Json -Depth 10 -Compress
+        }
+
+        Start-Job -ScriptBlock {
+            param($instanceId, $sessionId, $turnNum, $responseB64, $tools, $files)
+            try {
+                $decoded = [System.Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($responseB64))
+                & ekkos-capture response $instanceId $sessionId $turnNum $decoded $tools $files 2>&1 | Out-Null
+            } catch {}
+        } -ArgumentList $EkkosInstanceId, $rawSessionId, $turn, $responseBase64, $toolsJson, $filesJson | Out-Null
+    } catch {}
+}
+
+# ═══════════════════════════════════════════════════════════════════════════
+# WORKING MEMORY: Fast capture to API (async, non-blocking)
+# ═══════════════════════════════════════════════════════════════════════════
+$configFile = Join-Path $EkkosConfigDir "config.json"
+if (Test-Path $configFile) {
+    try {
+        $config = Get-Content $configFile -Raw | ConvertFrom-Json
+        $captureToken = $config.hookApiKey
+        if (-not $captureToken) { $captureToken = $config.apiKey }
+
+        if ($captureToken) {
+            Start-Job -ScriptBlock {
+                param($token, $instanceId, $sessionId, $sessionName, $turnNum, $response, $patterns)
+                $body = @{
+                    session_id = $sessionId
+                    session_name = $sessionName
+                    instance_id = $instanceId
+                    turn = $turnNum
+                    response = $response.Substring(0, [Math]::Min(5000, $response.Length))
+                    pattern_ids = $patterns
+                } | ConvertTo-Json -Depth 10
+
+                Invoke-RestMethod -Uri "https://mcp.ekkos.dev/api/v1/working/turn" `
+                    -Method POST `
+                    -Headers @{ Authorization = "Bearer $token" } `
+                    -ContentType "application/json" `
+                    -Body ([System.Text.Encoding]::UTF8.GetBytes($body)) -ErrorAction SilentlyContinue
+            } -ArgumentList $captureToken, $EkkosInstanceId, $rawSessionId, $sessionName, $turn, $assistantResponse, $patternIds | Out-Null
+        }
+    } catch {}
+}
+
+# Silent exit - assistant-response hook should not produce output
+exit 0