@ekkos/cli 1.0.33 → 1.0.35

package/templates/hooks/assistant-response.ps1

@@ -1,256 +1,160 @@
-# ═══════════════════════════════════════════════════════════════════════════
-# 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
+# ═══════════════════════════════════════════════════════════════════════════
+# 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