@ekkos/cli 1.0.36 → 1.1.0

package/dist/deploy/settings.js

@@ -4,42 +4,29 @@ exports.deployClaudeSettings = deployClaudeSettings;
 exports.areHooksConfigured = areHooksConfigured;
 const fs_1 = require("fs");
 const platform_1 = require("../utils/platform");
+function makeHook(command) {
+    return [{ matcher: '*', hooks: [{ type: 'command', command, timeout: 5000 }] }];
+}
 /**
  * Generate the hooks configuration for Claude Code settings.json
+ * Uses the correct Claude Code format: [{ matcher, hooks: [{ type, command, timeout }] }]
  */
 function generateHooksConfig() {
-    const hooksDir = `${platform_1.HOME_DIR}/.claude/hooks`;
+    const hooksDir = platform_1.CLAUDE_HOOKS_DIR;
     if (platform_1.isWindows) {
-        // Windows uses PowerShell
+        const ps = (name) => `powershell -ExecutionPolicy Bypass -File "${hooksDir}\\${name}.ps1"`;
         return {
-            SessionStart: [
-                { type: 'command', command: `powershell -ExecutionPolicy Bypass -File "${hooksDir}/session-start.ps1"` }
-            ],
-            UserPromptSubmit: [
-                { type: 'command', command: `powershell -ExecutionPolicy Bypass -File "${hooksDir}/user-prompt-submit.ps1"` }
-            ],
-            Stop: [
-                { type: 'command', command: `powershell -ExecutionPolicy Bypass -File "${hooksDir}/stop.ps1"` }
-            ],
-            AssistantResponse: [
-                { type: 'command', command: `powershell -ExecutionPolicy Bypass -File "${hooksDir}/assistant-response.ps1"` }
-            ]
+            SessionStart: makeHook(ps('session-start')),
+            UserPromptSubmit: makeHook(ps('user-prompt-submit')),
+            Stop: makeHook(ps('stop')),
         };
     }
     // Unix uses bash
+    const sh = (name) => `bash "${hooksDir}/${name}.sh"`;
     return {
-        SessionStart: [
-            { type: 'command', command: `bash ${hooksDir}/session-start.sh` }
-        ],
-        UserPromptSubmit: [
-            { type: 'command', command: `bash ${hooksDir}/user-prompt-submit.sh` }
-        ],
-        Stop: [
-            { type: 'command', command: `bash ${hooksDir}/stop.sh` }
-        ],
-        AssistantResponse: [
-            { type: 'command', command: `bash ${hooksDir}/assistant-response.sh` }
-        ]
+        SessionStart: makeHook(sh('session-start')),
+        UserPromptSubmit: makeHook(sh('user-prompt-submit')),
+        Stop: makeHook(sh('stop')),
     };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekkos/cli",
-  "version": "1.0.36",
+  "version": "1.1.0",
   "description": "Setup ekkOS memory for AI coding assistants (Claude Code, Cursor, Windsurf)",
   "main": "dist/index.js",
   "bin": {

package/templates/hooks/assistant-response.ps1

@@ -2,66 +2,117 @@
 # 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
+# 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"
-$EkkosInstanceId = if ($env:EKKOS_INSTANCE_ID) { $env:EKKOS_INSTANCE_ID } else { "default" }
 
-$MemoryApiUrl = "https://api.ekkos.dev"
+# ═══════════════════════════════════════════════════════════════════════════
+# INSTANCE ID - Multi-session isolation per v1.2 ADDENDUM
+# ═══════════════════════════════════════════════════════════════════════════
+$EkkosInstanceId = if ($env:EKKOS_INSTANCE_ID) { $env:EKKOS_INSTANCE_ID } else { "default" }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# CHECK ENABLEMENT
+# 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)) { return $true }
+    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 }
+            if ($enabledHooks -contains $HookName -or $enabledHooks -contains "assistant-response") {
+                return $true
+            }
             return $false
         }
-        return $true
-    } catch { return $true }
+
+        return $true  # Default to enabled if no config
+    } catch {
+        return $true  # Default to enabled on error
+    }
 }
 
-if (-not (Test-HookEnabled "assistant-response")) { exit 0 }
+# Check if this hook is enabled
+if (-not (Test-HookEnabled "assistant-response")) {
+    exit 0
+}
 
 # ═══════════════════════════════════════════════════════════════════════════
-# Load session words - NO HARDCODED ARRAYS
+# 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 }
+
+    # 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 }
+    } catch {
+        return $null
+    }
 }
 
+# ═══════════════════════════════════════════════════════════════════════════
+# SESSION NAME (UUID to words) - Uses external session-words.json
+# ═══════════════════════════════════════════════════════════════════════════
 function Convert-UuidToWords {
     param([string]$uuid)
-    if (-not $script:SessionWords) { Load-SessionWords }
-    if (-not $script:SessionWords) { return "unknown-session" }
+
+    # 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 $adjectives -or -not $nouns -or -not $verbs) {
+        return "unknown-session"
+    }
+
     if (-not $uuid -or $uuid -eq "unknown") { return "unknown-session" }
 
     $clean = $uuid -replace "-", ""
@@ -71,8 +122,11 @@ function Convert-UuidToWords {
         $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" }
+    } catch {
+        return "unknown-session"
+    }
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
@@ -81,16 +135,23 @@ function Convert-UuidToWords {
 $inputJson = [Console]::In.ReadToEnd()
 if (-not $inputJson) { exit 0 }
 
-try { $input = $inputJson | ConvertFrom-Json } catch { 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) {
@@ -106,13 +167,16 @@ $sessionName = Convert-UuidToWords $rawSessionId
 # ═══════════════════════════════════════════════════════════════════════════
 # READ TURN STATE
 # ═══════════════════════════════════════════════════════════════════════════
-$hookStateFile = Join-Path $env:USERPROFILE ".claude\state\hook-state.json"
+$stateFile = Join-Path $env:USERPROFILE ".claude\state\hook-state.json"
 $turn = 0
-if (Test-Path $hookStateFile) {
+
+if (Test-Path $stateFile) {
     try {
-        $hookState = Get-Content $hookStateFile -Raw | ConvertFrom-Json
+        $hookState = Get-Content $stateFile -Raw | ConvertFrom-Json
         $turn = [int]$hookState.turn
-    } catch { $turn = 0 }
+    } catch {
+        $turn = 0
+    }
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
@@ -120,6 +184,7 @@ if (Test-Path $hookStateFile) {
 # ═══════════════════════════════════════════════════════════════════════════
 $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
@@ -127,15 +192,18 @@ if ($assistantResponse -match '\[ekkOS_SELECT\]') {
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# LOCAL CACHE: Tier 0 capture (async)
+# 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
@@ -153,7 +221,7 @@ if ($captureCmd -and $rawSessionId -ne "unknown") {
 }
 
 # ═══════════════════════════════════════════════════════════════════════════
-# WORKING MEMORY: Fast capture to API (async)
+# WORKING MEMORY: Fast capture to API (async, non-blocking)
 # ═══════════════════════════════════════════════════════════════════════════
 $configFile = Join-Path $EkkosConfigDir "config.json"
 if (Test-Path $configFile) {
@@ -174,7 +242,7 @@ if (Test-Path $configFile) {
                     pattern_ids = $patterns
                 } | ConvertTo-Json -Depth 10
 
-                Invoke-RestMethod -Uri "https://api.ekkos.dev/api/v1/working/turn" `
+                Invoke-RestMethod -Uri "https://mcp.ekkos.dev/api/v1/working/turn" `
                     -Method POST `
                     -Headers @{ Authorization = "Bearer $token" } `
                     -ContentType "application/json" `

package/templates/hooks/hooks.json

@@ -2,26 +2,38 @@
   "hooks": {
     "SessionStart": [
       {
-        "type": "command",
-        "command": "bash .claude/hooks/session-start.sh"
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash .claude/hooks/session-start.sh",
+            "timeout": 5000
+          }
+        ]
       }
     ],
     "UserPromptSubmit": [
       {
-        "type": "command",
-        "command": "bash .claude/hooks/user-prompt-submit.sh"
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash .claude/hooks/user-prompt-submit.sh",
+            "timeout": 5000
+          }
+        ]
       }
     ],
     "Stop": [
       {
-        "type": "command",
-        "command": "bash .claude/hooks/stop.sh"
-      }
-    ],
-    "AssistantResponse": [
-      {
-        "type": "command",
-        "command": "bash .claude/hooks/assistant-response.sh"
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash .claude/hooks/stop.sh",
+            "timeout": 5000
+          }
+        ]
       }
     ]
   }