@ekkos/cli 1.2.18 → 1.3.1

package/templates/hooks/user-prompt-submit.ps1

@@ -1,419 +0,0 @@
-# ═══════════════════════════════════════════════════════════════════════════
-# ekkOS_ Hook: UserPromptSubmit - SEAMLESS CONTEXT CONTINUITY (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"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# PROXY MODE DETECTION
-# ═══════════════════════════════════════════════════════════════════════════
-$ProxyMode = $false
-if ($env:ANTHROPIC_BASE_URL -and $env:ANTHROPIC_BASE_URL -like "*proxy.ekkos.dev*") {
-    $ProxyMode = $true
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# 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
-
-    # 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
-    }
-}
-
-# Read input from stdin
-$inputJson = [Console]::In.ReadToEnd()
-if (-not $inputJson) { exit 0 }
-
-try {
-    $input = $inputJson | ConvertFrom-Json
-} catch {
-    exit 0
-}
-
-$userQuery = $input.query
-if (-not $userQuery) { $userQuery = $input.message }
-if (-not $userQuery) { $userQuery = $input.prompt }
-if (-not $userQuery) { exit 0 }
-
-$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 {}
-    }
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# PROXY MODE: Slim hook path (cosmetic output + local state only)
-# ═══════════════════════════════════════════════════════════════════════════
-if ($ProxyMode) {
-    function Get-ProxySessionName {
-        param([string]$sessionId)
-        if (-not $sessionId -or $sessionId -eq "unknown") { return "unknown-session" }
-        if ($sessionId -notmatch '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$') {
-            return $sessionId
-        }
-
-        if (-not $script:SessionWords) { Load-SessionWords }
-        if (-not $script:SessionWords) { return $sessionId }
-
-        $adjectives = $script:SessionWords.adjectives
-        $nouns = $script:SessionWords.nouns
-        $verbs = $script:SessionWords.verbs
-        if (-not $adjectives -or -not $nouns -or -not $verbs) { return $sessionId }
-
-        $clean = $sessionId -replace "-", ""
-        if ($clean.Length -lt 12) { return $sessionId }
-
-        try {
-            $adj = [Convert]::ToInt32($clean.Substring(0, 4), 16) % $adjectives.Length
-            $noun = [Convert]::ToInt32($clean.Substring(4, 4), 16) % $nouns.Length
-            $verb = [Convert]::ToInt32($clean.Substring(8, 4), 16) % $verbs.Length
-            return "$($adjectives[$adj])-$($nouns[$noun])-$($verbs[$verb])"
-        } catch {
-            return $sessionId
-        }
-    }
-
-    $sessionName = Get-ProxySessionName $rawSessionId
-    $timestampUtc = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
-    $displayTime = (Get-Date).ToString("yyyy-MM-dd hh:mm:ss tt zzz")
-    $projectPath = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
-
-    New-Item -ItemType Directory -Path $EkkosConfigDir -Force | Out-Null
-    New-Item -ItemType Directory -Path (Join-Path $env:USERPROFILE ".claude\state") -Force | Out-Null
-
-    $globalState = @{
-        session_id = $rawSessionId
-        session_name = $sessionName
-        project = $projectPath
-        timestamp = $timestampUtc
-    } | ConvertTo-Json -Depth 10 -Compress
-    Set-Content -Path (Join-Path $EkkosConfigDir "current-session.json") -Value $globalState -Force
-
-    $localState = @{
-        session_id = $rawSessionId
-        session_name = $sessionName
-        timestamp = $timestampUtc
-    } | ConvertTo-Json -Depth 10 -Compress
-    Set-Content -Path (Join-Path $env:USERPROFILE ".claude\state\current-session.json") -Value $localState -Force
-
-    $activeSessionsPath = Join-Path $EkkosConfigDir "active-sessions.json"
-    $sessions = @()
-    if (Test-Path $activeSessionsPath) {
-        try { $sessions = @(Get-Content $activeSessionsPath -Raw | ConvertFrom-Json) } catch { $sessions = @() }
-    }
-
-    $entry = @{
-        sessionId = $rawSessionId
-        sessionName = $sessionName
-        projectPath = $projectPath
-        startedAt = $timestampUtc
-        lastHeartbeat = $timestampUtc
-        pid = 0
-    }
-    $idx = -1
-    for ($i = 0; $i -lt $sessions.Count; $i++) {
-        if ($sessions[$i].sessionId -eq $rawSessionId) { $idx = $i; break }
-    }
-    if ($idx -ge 0) {
-        $entry.startedAt = if ($sessions[$idx].startedAt) { $sessions[$idx].startedAt } else { $timestampUtc }
-        $sessions[$idx] = $entry
-    } else {
-        $sessions += $entry
-    }
-    Set-Content -Path $activeSessionsPath -Value ($sessions | ConvertTo-Json -Depth 10) -Force
-
-    $hint = @{
-        sessionName = $sessionName
-        sessionId = $rawSessionId
-        projectPath = $projectPath
-        ts = [DateTimeOffset]::UtcNow.ToUnixTimeMilliseconds()
-    } | ConvertTo-Json -Depth 10 -Compress
-    Set-Content -Path (Join-Path $EkkosConfigDir "hook-session-hint.json") -Value $hint -Force
-
-    $esc = [char]27
-    Write-Output "${esc}[0;36m${esc}[1m🧠 ekkOS Memory${esc}[0m ${esc}[2m| $sessionName | $displayTime${esc}[0m"
-    exit 0
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# INTELLIGENT TOOL ROUTER: Multi-trigger skill detection
-# ═══════════════════════════════════════════════════════════════════════════
-$skillReminders = @()
-$queryLower = $userQuery.ToLower()
-
-# Memory First - Debug/Error/Problem solving
-if ($queryLower -match '(how do i|debug|error|bug|fix|not working|broken|fails|issue|problem|wrong|crash)') {
-    $skillReminders += "SKILL REQUIRED: Call Skill(skill: `"ekkOS_Memory_First`") FIRST before debugging"
-}
-
-# Recall Triggers - Time-based memory
-if ($queryLower -match '(yesterday|last week|last month|remember when|what did we|where did we leave|before|earlier|previous|ago)') {
-    $skillReminders += "SKILL REQUIRED: Call Skill(skill: `"ekkOS_Deep_Recall`") for time-based memory"
-}
-
-# Directive Triggers - User preferences
-if ($queryLower -match '(always |never |i prefer|i like |dont |don.t |avoid |remember that |from now on)') {
-    $skillReminders += "SKILL REQUIRED: Call Skill(skill: `"ekkOS_Preferences`") to capture directive"
-}
-
-# Safety Triggers - Destructive actions
-if ($queryLower -match '(delete|drop |rm -rf|deploy|push.*main|push.*master|production|migrate|rollback)') {
-    $skillReminders += "SAFETY REQUIRED: Call ekkOS_Conflict before this destructive action"
-}
-
-# Schema Triggers - Database operations
-if ($queryLower -match '(sql|query|supabase|prisma|database|table|column|select |insert |update |where )') {
-    $skillReminders += "SCHEMA REQUIRED: Call ekkOS_GetSchema for correct field names"
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# SESSION NAME - Resolve early so it's available for all downstream use
-# ═══════════════════════════════════════════════════════════════════════════
-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"
-    }
-}
-
-$sessionName = Convert-UuidToWords $rawSessionId
-
-function Get-PendingSessionFromProxyBaseUrl {
-    param([string]$baseUrl)
-    if (-not $baseUrl) { return $null }
-    try {
-        $uri = [System.Uri]$baseUrl
-        $segments = $uri.AbsolutePath.Trim('/') -split '/'
-        if (-not $segments -or $segments.Count -lt 3) { return $null }
-        $proxyIndex = [Array]::IndexOf($segments, 'proxy')
-        if ($proxyIndex -lt 0 -or $segments.Count -le ($proxyIndex + 2)) { return $null }
-        $candidate = [System.Uri]::UnescapeDataString($segments[$proxyIndex + 2])
-        if ($candidate -eq '_pending' -or $candidate -eq 'pending' -or $candidate.StartsWith('_pending-')) {
-            return $candidate
-        }
-    } catch {}
-    return $null
-}
-# Session binding removed — proxy now self-resolves _pending → word-based
-# names inline via uuidToSessionName(). No external bind call needed.
-
-# ═══════════════════════════════════════════════════════════════════════════
-# SESSION CURRENT: Update Redis with current session name
-# ═══════════════════════════════════════════════════════════════════════════
-if ($sessionName -ne "unknown-session" -and $rawSessionId -ne "unknown") {
-    $configFile2 = Join-Path $EkkosConfigDir "config.json"
-    if (Test-Path $configFile2) {
-        try {
-            $config2 = Get-Content $configFile2 -Raw | ConvertFrom-Json
-            $sessionToken = $config2.hookApiKey
-            if (-not $sessionToken) { $sessionToken = $config2.apiKey }
-            if ($sessionToken) {
-                $sessionBody = @{ session_name = $sessionName } | ConvertTo-Json -Depth 10
-                Start-Job -ScriptBlock {
-                    param($body, $token)
-                    Invoke-RestMethod -Uri "https://mcp.ekkos.dev/api/v1/working/session/current" `
-                        -Method POST `
-                        -Headers @{ Authorization = "Bearer $token"; "Content-Type" = "application/json" } `
-                        -Body ([System.Text.Encoding]::UTF8.GetBytes($body)) -ErrorAction SilentlyContinue | Out-Null
-                } -ArgumentList $sessionBody, $sessionToken | Out-Null
-            }
-        } catch {}
-    }
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# TURN TRACKING & STATE MANAGEMENT
-# ═══════════════════════════════════════════════════════════════════════════
-$stateDir = Join-Path $env:USERPROFILE ".claude\state"
-if (-not (Test-Path $stateDir)) {
-    New-Item -ItemType Directory -Path $stateDir -Force | Out-Null
-}
-
-$stateFile = Join-Path $stateDir "hook-state.json"
-$turn = 0
-$contextPercent = ""
-
-if (Test-Path $stateFile) {
-    try {
-        $hookState = Get-Content $stateFile -Raw | ConvertFrom-Json
-        # Only continue incrementing if this state belongs to the SAME session.
-        # If session changed, reset turn counter to 0.
-        if ($hookState.session_id -eq $rawSessionId) {
-            $turn = [int]$hookState.turn + 1
-        } else {
-            $turn = 0
-        }
-    } catch {
-        $turn = 0
-    }
-}
-
-# Save updated state
-$newState = @{
-    turn = $turn
-    session_id = $rawSessionId
-    last_query = $userQuery.Substring(0, [Math]::Min(100, $userQuery.Length))
-    timestamp = (Get-Date).ToString("o")
-} | ConvertTo-Json -Depth 10
-
-Set-Content -Path $stateFile -Value $newState -Force
-
-# ═══════════════════════════════════════════════════════════════════════════
-# 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 user <instance_id> <session_id> <session_name> <turn_id> <query> [project_path]
-        $queryBase64 = [Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($userQuery))
-        $projectRoot = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
-
-        Start-Job -ScriptBlock {
-            param($instanceId, $sessionId, $sessionName, $turnNum, $queryB64, $projectPath)
-            try {
-                $decoded = [System.Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($queryB64))
-                & ekkos-capture user $instanceId $sessionId $sessionName $turnNum $decoded $projectPath 2>&1 | Out-Null
-            } catch {}
-        } -ArgumentList $EkkosInstanceId, $rawSessionId, $sessionName, $turn, $queryBase64, $projectRoot | 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) {
-            # Async capture using Start-Job (non-blocking)
-            Start-Job -ScriptBlock {
-                param($token, $instanceId, $sessionId, $sessionName, $turnNum, $query)
-                $body = @{
-                    session_id = $sessionId
-                    session_name = $sessionName
-                    instance_id = $instanceId
-                    turn = $turnNum
-                    query = $query
-                } | ConvertTo-Json -Depth 10
-
-                Invoke-RestMethod -Uri "https://mcp.ekkos.dev/api/v1/working/fast-capture" `
-                    -Method POST `
-                    -Headers @{ Authorization = "Bearer $token" } `
-                    -ContentType "application/json" `
-                    -Body ([System.Text.Encoding]::UTF8.GetBytes($body)) -ErrorAction SilentlyContinue
-            } -ArgumentList $captureToken, $EkkosInstanceId, $rawSessionId, $sessionName, $turn, $userQuery | Out-Null
-        }
-    } catch {}
-}
-
-$timestamp = (Get-Date).ToString("yyyy-MM-dd hh:mm:ss tt") + " EST"
-
-# ═══════════════════════════════════════════════════════════════════════════
-# DASHBOARD HINT FILE: write session info for ekkos dashboard --wait-for-new
-# On Windows, active-sessions.json is never populated (hook PIDs are dead).
-# The dashboard reads this file instead to locate the JSONL path.
-# ═══════════════════════════════════════════════════════════════════════════
-if ($sessionName -ne "unknown-session") {
-    try {
-        $projectPath = if ($env:PWD) { $env:PWD } else { (Get-Location).Path }
-        $hintFile = Join-Path $EkkosConfigDir "hook-session-hint.json"
-        $hint = @{
-            sessionName = $sessionName
-            sessionId   = $rawSessionId
-            projectPath = $projectPath
-            ts          = [DateTimeOffset]::UtcNow.ToUnixTimeMilliseconds()
-        } | ConvertTo-Json -Depth 10 -Compress
-        Set-Content -Path $hintFile -Value $hint -Force
-    } catch {}
-}
-
-# ═══════════════════════════════════════════════════════════════════════════
-# OUTPUT SYSTEM REMINDER
-# ═══════════════════════════════════════════════════════════════════════════
-$esc = [char]27
-$header = "${esc}[0;36m${esc}[1m🧠 ekkOS Memory${esc}[0m ${esc}[2m| $sessionName | $timestamp${esc}[0m"
-
-$output = @"
-$header
-
-"@
-
-if ($skillReminders.Count -gt 0) {
-    $output += "${esc}[0;35m${esc}[1m" + ($skillReminders -join "`n") + "${esc}[0m`n"
-}
-
-$output += @"
-
-<footer-format>End responses with: Claude Code ({Model}) · 🧠 ekkOS_™ · $sessionName · $timestamp</footer-format>
-<footer-note>Do not include a turn counter in the footer.</footer-note>
-"@
-
-Write-Output $output