@ekkos/cli 0.2.0

package/dist/commands/setup.d.ts

@@ -0,0 +1,6 @@
+interface SetupOptions {
+    ide: string;
+    key?: string;
+}
+export declare function setup(options: SetupOptions): Promise<void>;
+export {};

package/dist/commands/setup.js

@@ -0,0 +1,658 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setup = setup;
+const os_1 = require("os");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const ora_1 = __importDefault(require("ora"));
+const EKKOS_API_URL = 'https://mcp.ekkos.dev';
+const CONFIG_DIR = (0, path_1.join)((0, os_1.homedir)(), '.ekkos');
+const CONFIG_FILE = (0, path_1.join)(CONFIG_DIR, 'config.json');
+/**
+ * Auto-detect which IDE the user is running in
+ */
+function detectIDE() {
+    // Check TERM_PROGRAM environment variable (set by many terminals/IDEs)
+    const termProgram = process.env.TERM_PROGRAM?.toLowerCase() || '';
+    const termEmulator = process.env.TERMINAL_EMULATOR?.toLowerCase() || '';
+    const colorterm = process.env.COLORTERM?.toLowerCase() || '';
+    // Cursor sets TERM_PROGRAM
+    if (termProgram.includes('cursor')) {
+        return 'cursor';
+    }
+    // VSCode sets TERM_PROGRAM to "vscode"
+    if (termProgram.includes('vscode') || termEmulator.includes('vscode')) {
+        return 'vscode';
+    }
+    // Windsurf/Codeium detection
+    if (termProgram.includes('windsurf') || termProgram.includes('codeium')) {
+        return 'windsurf';
+    }
+    // Check for Windsurf by config directory existence (if recently used)
+    const windsurfConfig = (0, path_1.join)((0, os_1.homedir)(), '.codeium', 'windsurf');
+    if ((0, fs_1.existsSync)(windsurfConfig)) {
+        // Also check if there's activity (mcp_config.json exists or was modified recently)
+        const mcpConfig = (0, path_1.join)(windsurfConfig, 'mcp_config.json');
+        if ((0, fs_1.existsSync)(mcpConfig)) {
+            // Windsurf is installed and configured - suggest it
+            // But don't return it as definitive without env var
+        }
+    }
+    // Check for Claude Code by looking at parent process or specific env vars
+    // Claude Code typically runs in a terminal context
+    if (process.env.CLAUDE_CODE || process.env.ANTHROPIC_API_KEY) {
+        return 'claude-code';
+    }
+    // Check ~/.claude directory for Claude Code usage
+    const claudeDir = (0, path_1.join)((0, os_1.homedir)(), '.claude');
+    if ((0, fs_1.existsSync)(claudeDir)) {
+        const hooksDir = (0, path_1.join)(claudeDir, 'hooks');
+        if ((0, fs_1.existsSync)(hooksDir)) {
+            // Claude Code has been set up before
+        }
+    }
+    // Check for cursor config directory
+    const cursorDir = (0, path_1.join)((0, os_1.homedir)(), '.cursor');
+    if ((0, fs_1.existsSync)(cursorDir)) {
+        // Cursor is installed
+    }
+    return null;
+}
+async function setup(options) {
+    console.log('');
+    console.log(chalk_1.default.cyan.bold('🧠 ekkOS Setup'));
+    console.log(chalk_1.default.gray('─'.repeat(50)));
+    console.log('');
+    // Get API key
+    let apiKey = options.key || process.env.EKKOS_API_KEY;
+    if (!apiKey) {
+        console.log(chalk_1.default.yellow('Get your API key from: https://ekkos.dev/dashboard/keys'));
+        console.log('');
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'password',
+                name: 'apiKey',
+                message: 'Enter your ekkOS API key:',
+                mask: '*',
+                validate: (input) => {
+                    if (!input || input.length < 10) {
+                        return 'Please enter a valid API key';
+                    }
+                    return true;
+                }
+            }
+        ]);
+        apiKey = answers.apiKey;
+    }
+    // Verify API key
+    const spinner = (0, ora_1.default)('Verifying API key...').start();
+    try {
+        const response = await fetch(`${EKKOS_API_URL}/api/v1/patterns/query`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ query: 'test', k: 1 })
+        });
+        if (!response.ok) {
+            spinner.fail('Invalid API key');
+            console.log(chalk_1.default.red('Please check your API key and try again.'));
+            process.exit(1);
+        }
+        spinner.succeed('API key verified');
+    }
+    catch (error) {
+        spinner.fail('Could not connect to ekkOS');
+        console.log(chalk_1.default.red('Check your internet connection and try again.'));
+        process.exit(1);
+    }
+    // Save config
+    if (!(0, fs_1.existsSync)(CONFIG_DIR)) {
+        (0, fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
+    }
+    const config = {
+        apiKey: apiKey,
+        installedIDEs: [],
+        installedAt: new Date().toISOString()
+    };
+    // Determine which IDE to setup
+    let ideToSetup;
+    if (options.ide === 'all') {
+        // Try to auto-detect the IDE
+        const detectedIDE = detectIDE();
+        if (detectedIDE) {
+            console.log(chalk_1.default.green(`✓ Detected IDE: ${detectedIDE}`));
+            console.log('');
+        }
+        const ideAnswers = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'ide',
+                message: 'Which IDE are you setting up?',
+                choices: [
+                    { name: 'Claude Code (CLI)', value: 'claude-code' },
+                    { name: 'Cursor', value: 'cursor' },
+                    { name: 'Windsurf (Cascade)', value: 'windsurf' },
+                    { name: 'VSCode (Copilot)', value: 'vscode' }
+                ],
+                default: detectedIDE || 'cursor'
+            }
+        ]);
+        ideToSetup = ideAnswers.ide;
+    }
+    else {
+        ideToSetup = options.ide;
+    }
+    console.log('');
+    // Setup the selected IDE
+    await setupIDE(ideToSetup, apiKey, config);
+    // Save final config
+    (0, fs_1.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2));
+    // Summary
+    console.log('');
+    console.log(chalk_1.default.green.bold('✅ Setup complete!'));
+    console.log('');
+    console.log(chalk_1.default.gray('─'.repeat(50)));
+    console.log('');
+    console.log('Configured IDEs:');
+    for (const ide of config.installedIDEs) {
+        console.log(chalk_1.default.cyan(`  • ${ide}`));
+    }
+    console.log('');
+    console.log('Next steps:');
+    console.log(chalk_1.default.gray('  1. Open your IDE'));
+    console.log(chalk_1.default.gray('  2. Start coding - memory is now active'));
+    console.log(chalk_1.default.gray('  3. Watch patterns form as you work'));
+    console.log('');
+    console.log(chalk_1.default.cyan('View your memory at: https://ekkos.dev/dashboard'));
+    console.log('');
+}
+async function setupIDE(ide, apiKey, config) {
+    const spinner = (0, ora_1.default)(`Setting up ${ide}...`).start();
+    try {
+        switch (ide) {
+            case 'claude-code':
+                await setupClaudeCode(apiKey);
+                break;
+            case 'cursor':
+                await setupCursor(apiKey);
+                break;
+            case 'windsurf':
+                await setupWindsurf(apiKey);
+                break;
+            case 'vscode':
+                await setupVSCode(apiKey);
+                break;
+            default:
+                spinner.warn(`Unknown IDE: ${ide}`);
+                return;
+        }
+        config.installedIDEs.push(ide);
+        spinner.succeed(`${ide} configured`);
+    }
+    catch (error) {
+        spinner.fail(`Failed to setup ${ide}: ${error}`);
+    }
+}
+async function setupClaudeCode(apiKey) {
+    const claudeDir = (0, path_1.join)((0, os_1.homedir)(), '.claude');
+    const hooksDir = (0, path_1.join)(claudeDir, 'hooks');
+    if (!(0, fs_1.existsSync)(hooksDir)) {
+        (0, fs_1.mkdirSync)(hooksDir, { recursive: true });
+    }
+    const isWindows = (0, os_1.platform)() === 'win32';
+    if (isWindows) {
+        // Windows: PowerShell hooks
+        const promptSubmitHook = generatePromptSubmitHookPS(apiKey);
+        const promptSubmitPath = (0, path_1.join)(hooksDir, 'user-prompt-submit.ps1');
+        (0, fs_1.writeFileSync)(promptSubmitPath, promptSubmitHook);
+        const stopHook = generateStopHookPS(apiKey);
+        const stopPath = (0, path_1.join)(hooksDir, 'stop.ps1');
+        (0, fs_1.writeFileSync)(stopPath, stopHook);
+        // Create wrapper batch files for Windows
+        (0, fs_1.writeFileSync)((0, path_1.join)(hooksDir, 'user-prompt-submit.cmd'), `@echo off\npowershell -ExecutionPolicy Bypass -File "%~dp0user-prompt-submit.ps1"`);
+        (0, fs_1.writeFileSync)((0, path_1.join)(hooksDir, 'stop.cmd'), `@echo off\npowershell -ExecutionPolicy Bypass -File "%~dp0stop.ps1"`);
+    }
+    else {
+        // Unix: Bash hooks
+        const promptSubmitHook = generatePromptSubmitHook(apiKey);
+        const promptSubmitPath = (0, path_1.join)(hooksDir, 'user-prompt-submit.sh');
+        (0, fs_1.writeFileSync)(promptSubmitPath, promptSubmitHook);
+        (0, fs_1.chmodSync)(promptSubmitPath, '755');
+        const stopHook = generateStopHook(apiKey);
+        const stopPath = (0, path_1.join)(hooksDir, 'stop.sh');
+        (0, fs_1.writeFileSync)(stopPath, stopHook);
+        (0, fs_1.chmodSync)(stopPath, '755');
+    }
+    // Create state directory
+    const stateDir = (0, path_1.join)(claudeDir, 'state');
+    if (!(0, fs_1.existsSync)(stateDir)) {
+        (0, fs_1.mkdirSync)(stateDir, { recursive: true });
+    }
+}
+async function setupCursor(apiKey) {
+    // Cursor uses .cursorrules for system prompt
+    // and MCP servers for tools
+    const cursorDir = (0, path_1.join)((0, os_1.homedir)(), '.cursor');
+    if (!(0, fs_1.existsSync)(cursorDir)) {
+        (0, fs_1.mkdirSync)(cursorDir, { recursive: true });
+    }
+    // Create/update MCP settings
+    const mcpConfigPath = (0, path_1.join)(cursorDir, 'mcp.json');
+    let mcpConfig = {};
+    if ((0, fs_1.existsSync)(mcpConfigPath)) {
+        try {
+            mcpConfig = JSON.parse((0, fs_1.readFileSync)(mcpConfigPath, 'utf-8'));
+        }
+        catch { }
+    }
+    mcpConfig.mcpServers = mcpConfig.mcpServers || {};
+    mcpConfig.mcpServers['ekkos-memory'] = {
+        command: 'npx',
+        args: ['@ekkos/mcp-server'],
+        env: {
+            EKKOS_API_KEY: apiKey
+        }
+    };
+    (0, fs_1.writeFileSync)(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+    // Create .cursorrules template in current directory
+    const cursorRules = generateCursorRules();
+    const cursorRulesPath = (0, path_1.join)(process.cwd(), '.cursorrules');
+    if (!(0, fs_1.existsSync)(cursorRulesPath)) {
+        (0, fs_1.writeFileSync)(cursorRulesPath, cursorRules);
+    }
+}
+async function setupWindsurf(apiKey) {
+    // Windsurf (Codeium) supports MCP servers like Cursor
+    // Config location: ~/.codeium/windsurf/mcp_config.json
+    const codeiumDir = (0, path_1.join)((0, os_1.homedir)(), '.codeium', 'windsurf');
+    if (!(0, fs_1.existsSync)(codeiumDir)) {
+        (0, fs_1.mkdirSync)(codeiumDir, { recursive: true });
+    }
+    // Create/update MCP config for Windsurf
+    const mcpConfigPath = (0, path_1.join)(codeiumDir, 'mcp_config.json');
+    let mcpConfig = { mcpServers: {} };
+    if ((0, fs_1.existsSync)(mcpConfigPath)) {
+        try {
+            mcpConfig = JSON.parse((0, fs_1.readFileSync)(mcpConfigPath, 'utf-8'));
+            mcpConfig.mcpServers = mcpConfig.mcpServers || {};
+        }
+        catch { }
+    }
+    // Add ekkOS cloud MCP server (HTTP transport)
+    mcpConfig.mcpServers['ekkos-memory'] = {
+        serverUrl: 'https://mcp.ekkos.dev',
+        disabled: false,
+        alwaysAllow: [],
+        headers: {
+            'Authorization': `Bearer ${apiKey}`
+        }
+    };
+    (0, fs_1.writeFileSync)(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+    // Also save to legacy location for backwards compat
+    const windsurfDir = (0, path_1.join)((0, os_1.homedir)(), '.windsurf');
+    if (!(0, fs_1.existsSync)(windsurfDir)) {
+        (0, fs_1.mkdirSync)(windsurfDir, { recursive: true });
+    }
+    (0, fs_1.writeFileSync)((0, path_1.join)(windsurfDir, 'ekkos.json'), JSON.stringify({ apiKey }, null, 2));
+    // Create project rules template
+    const cascadeRules = generateCascadeRules();
+    const cascadeRulesPath = (0, path_1.join)(process.cwd(), '.windsurfrules');
+    if (!(0, fs_1.existsSync)(cascadeRulesPath)) {
+        (0, fs_1.writeFileSync)(cascadeRulesPath, cascadeRules);
+    }
+}
+async function setupVSCode(apiKey) {
+    // VSCode - create settings for Copilot/Continue
+    const vscodeDir = (0, path_1.join)((0, os_1.homedir)(), '.vscode');
+    if (!(0, fs_1.existsSync)(vscodeDir)) {
+        (0, fs_1.mkdirSync)(vscodeDir, { recursive: true });
+    }
+    // Save config
+    const configPath = (0, path_1.join)(vscodeDir, 'ekkos.json');
+    (0, fs_1.writeFileSync)(configPath, JSON.stringify({ apiKey }, null, 2));
+    // Note: Full VSCode integration requires extension
+    console.log(chalk_1.default.yellow('  Note: VSCode requires the ekkOS extension for full integration'));
+}
+function generatePromptSubmitHook(apiKey) {
+    return `#!/bin/bash
+# ekkOS Hook: UserPromptSubmit
+# Golden Loop: RETRIEVE → INJECT
+
+set -e
+
+EKKOS_API_KEY="${apiKey}"
+MEMORY_API_URL="https://mcp.ekkos.dev"
+STATE_DIR="$HOME/.claude/state"
+mkdir -p "$STATE_DIR"
+
+INPUT=$(cat)
+USER_QUERY=$(echo "$INPUT" | jq -r '.query // .message // .prompt // ""')
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // "unknown"')
+MODEL_INFO=$(echo "$INPUT" | jq -r '.model // "claude-sonnet-4-5"')
+
+if [ -z "$USER_QUERY" ] || [ "$USER_QUERY" = "null" ]; then
+  exit 0
+fi
+
+TASK_ID="task-\${SESSION_ID}-$(date +%s)"
+TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+echo ""
+echo "[ekkOS_RETRIEVE] Searching memory..."
+
+JSON_PAYLOAD=$(cat << EOF
+{
+  "query": $(echo "$USER_QUERY" | jq -R -s .),
+  "k": 5,
+  "model_used": "$MODEL_INFO"
+}
+EOF
+)
+
+API_RESPONSE=$(curl -s -X POST "$MEMORY_API_URL/api/v1/patterns/query" \\
+  -H "Authorization: Bearer $EKKOS_API_KEY" \\
+  -H "Content-Type: application/json" \\
+  -d "$JSON_PAYLOAD" \\
+  --connect-timeout 3 \\
+  --max-time 5 2>/dev/null || echo '{"patterns":[]}')
+
+PATTERNS=$(echo "$API_RESPONSE" | jq '.patterns // []' 2>/dev/null || echo "[]")
+PATTERN_COUNT=$(echo "$PATTERNS" | jq 'length' 2>/dev/null || echo "0")
+
+if [ "$PATTERN_COUNT" -gt 0 ]; then
+  echo "[ekkOS_RETRIEVE] Found $PATTERN_COUNT patterns"
+else
+  echo "[ekkOS_RETRIEVE] No patterns found (building memory)"
+fi
+
+# Store state
+PATTERN_DATA=$(cat << EOF
+{
+  "patterns": $PATTERNS,
+  "model_used": "$MODEL_INFO",
+  "task_id": "$TASK_ID",
+  "retrieved_at": "$TIMESTAMP",
+  "query": $(echo "$USER_QUERY" | jq -R -s .)
+}
+EOF
+)
+echo "$PATTERN_DATA" > "$STATE_DIR/patterns-\${SESSION_ID}.json"
+
+# Display patterns
+if [ "$PATTERN_COUNT" -gt 0 ]; then
+  AVG_SUCCESS=$(echo "$PATTERNS" | jq '[.[].success_rate // 0.9] | add / length * 100 | round' 2>/dev/null || echo "90")
+  echo "[ekkOS_INJECT] Loading $PATTERN_COUNT patterns (\${AVG_SUCCESS}% avg success)"
+  echo ""
+
+  echo "$PATTERNS" | jq -c '.[:5] | .[]' 2>/dev/null | while read -r pattern; do
+    TITLE=$(echo "$pattern" | jq -r '.title // "Untitled"')
+    SUCCESS_RATE=$(echo "$pattern" | jq -r 'if .success_rate then (.success_rate * 100 | round | tostring) + "%" else "~80%" end')
+    APPLIED_COUNT=$(echo "$pattern" | jq -r '.applied_count // 0')
+    GUIDANCE=$(echo "$pattern" | jq -r '.guidance // .content // "No guidance"')
+
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "🧠 PATTERN: \\"$TITLE\\""
+    echo "   Applied \${APPLIED_COUNT}x | \${SUCCESS_RATE} success"
+    echo ""
+    echo "   $GUIDANCE" | head -c 500
+    echo ""
+  done
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+fi
+
+echo ""
+echo "[ekkOS_LEARN] 🔥 FORGE new patterns when you solve something!"
+echo ""
+
+exit 0
+`;
+}
+function generateStopHook(apiKey) {
+    return `#!/bin/bash
+# ekkOS Hook: Stop
+# Golden Loop: CAPTURE → MEASURE
+
+set -e
+
+EKKOS_API_KEY="${apiKey}"
+MEMORY_API_URL="https://mcp.ekkos.dev"
+STATE_DIR="$HOME/.claude/state"
+
+INPUT=$(cat)
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // "unknown"')
+TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+PATTERNS_FILE="$STATE_DIR/patterns-\${SESSION_ID}.json"
+PATTERN_COUNT=0
+
+if [ -f "$PATTERNS_FILE" ]; then
+  STORED_DATA=$(cat "$PATTERNS_FILE" 2>/dev/null || echo "{}")
+  PATTERNS=$(echo "$STORED_DATA" | jq '.patterns // []' 2>/dev/null || echo "[]")
+  PATTERN_COUNT=$(echo "$PATTERNS" | jq 'length' 2>/dev/null || echo "0")
+fi
+
+echo ""
+echo "[ekkOS_CAPTURE] ✓ Session saved"
+
+if [ "$PATTERN_COUNT" -gt 0 ]; then
+  echo "[ekkOS_MEASURE] ✓ Tracked $PATTERN_COUNT patterns"
+fi
+
+rm -f "$PATTERNS_FILE" 2>/dev/null
+
+echo ""
+echo "┌─────────────────────────────────────────────┐"
+echo "│  ekkOS_ GOLDEN LOOP COMPLETE                │"
+echo "│  The system learns from every interaction.  │"
+echo "└─────────────────────────────────────────────┘"
+echo ""
+
+exit 0
+`;
+}
+function generateCursorRules() {
+    return `# ekkOS Golden Loop Integration
+
+## Memory System Active
+
+Before responding, check ekkOS memory for relevant patterns using the MCP tools:
+- \`ekkOS_Search\` - Find patterns that match the current problem
+- \`ekkOS_Forge\` - Save new patterns when you solve something
+
+## When to FORGE New Patterns
+
+Use \`ekkOS_Forge\` when you:
+- Fixed a non-obvious bug
+- Found a better approach
+- Discovered a pitfall
+- User corrected you
+
+## Pattern Application
+
+When you use a pattern from memory:
+\`\`\`
+[ekkOS_APPLY] Using: "Pattern Name"
+\`\`\`
+
+This is how ekkOS learns and improves over time.
+`;
+}
+function generateCascadeRules() {
+    return `# ekkOS Memory Integration for Windsurf
+
+## Active Learning
+
+This project uses ekkOS for persistent AI memory.
+
+When solving problems:
+1. Check if similar patterns exist in memory
+2. Apply proven solutions when they match
+3. Create new patterns when you solve something novel
+
+## Creating Patterns
+
+When you solve a problem that others might encounter:
+- Document the problem clearly
+- Explain the solution
+- Note any anti-patterns to avoid
+
+The system learns from every interaction.
+`;
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// WINDOWS POWERSHELL HOOKS
+// ═══════════════════════════════════════════════════════════════════════════
+function generatePromptSubmitHookPS(apiKey) {
+    return `# ekkOS Hook: UserPromptSubmit (Windows PowerShell)
+# Golden Loop: RETRIEVE → INJECT
+
+$ErrorActionPreference = "Stop"
+
+$EKKOS_API_KEY = "${apiKey}"
+$MEMORY_API_URL = "https://mcp.ekkos.dev"
+$STATE_DIR = "$env:USERPROFILE\\.claude\\state"
+
+if (!(Test-Path $STATE_DIR)) {
+    New-Item -ItemType Directory -Path $STATE_DIR -Force | Out-Null
+}
+
+$INPUT = $input | Out-String
+$jsonInput = $INPUT | ConvertFrom-Json -ErrorAction SilentlyContinue
+
+$USER_QUERY = if ($jsonInput.query) { $jsonInput.query } elseif ($jsonInput.message) { $jsonInput.message } elseif ($jsonInput.prompt) { $jsonInput.prompt } else { "" }
+$SESSION_ID = if ($jsonInput.session_id) { $jsonInput.session_id } else { "unknown" }
+$MODEL_INFO = if ($jsonInput.model) { $jsonInput.model } else { "claude-sonnet-4-5" }
+
+if ([string]::IsNullOrEmpty($USER_QUERY)) {
+    exit 0
+}
+
+$TASK_ID = "claude-code-task-$SESSION_ID-$([DateTimeOffset]::Now.ToUnixTimeSeconds())"
+$TIMESTAMP = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
+
+Write-Host ""
+Write-Host "[ekkOS_RETRIEVE] Searching memory..."
+
+$body = @{
+    query = $USER_QUERY
+    k = 5
+    model_used = $MODEL_INFO
+} | ConvertTo-Json
+
+try {
+    $response = Invoke-RestMethod -Uri "$MEMORY_API_URL/api/v1/patterns/query" \`
+        -Method Post \`
+        -Headers @{ "Authorization" = "Bearer $EKKOS_API_KEY"; "Content-Type" = "application/json" } \`
+        -Body $body \`
+        -TimeoutSec 5
+
+    $PATTERNS = $response.patterns
+    $PATTERN_COUNT = if ($PATTERNS) { $PATTERNS.Count } else { 0 }
+} catch {
+    $PATTERNS = @()
+    $PATTERN_COUNT = 0
+}
+
+if ($PATTERN_COUNT -gt 0) {
+    Write-Host "[ekkOS_RETRIEVE] Found $PATTERN_COUNT patterns"
+} else {
+    Write-Host "[ekkOS_RETRIEVE] No patterns found (new territory)"
+}
+
+# Store for stop hook
+$PATTERN_DATA = @{
+    patterns = $PATTERNS
+    model_used = $MODEL_INFO
+    task_id = $TASK_ID
+    retrieved_at = $TIMESTAMP
+    query = $USER_QUERY.Substring(0, [Math]::Min($USER_QUERY.Length, 1000))
+} | ConvertTo-Json -Depth 10
+
+$PATTERN_DATA | Out-File -FilePath "$STATE_DIR\\patterns-$SESSION_ID.json" -Encoding UTF8
+
+# Display patterns
+if ($PATTERN_COUNT -gt 0) {
+    $rates = $PATTERNS | ForEach-Object { if ($_.success_rate) { $_.success_rate } else { 0.9 } }
+    $AVG_SUCCESS = [math]::Round(($rates | Measure-Object -Average).Average * 100)
+
+    Write-Host "[ekkOS_INJECT] Loading $PATTERN_COUNT patterns ($AVG_SUCCESS% avg success)"
+    Write-Host ""
+
+    $idx = 0
+    foreach ($pattern in $PATTERNS | Select-Object -First 5) {
+        $idx++
+        $TITLE = if ($pattern.title) { $pattern.title } else { "Untitled" }
+        $SUCCESS_RATE = if ($pattern.success_rate) { "$([math]::Round($pattern.success_rate * 100))%" } else { "~80%" }
+        $APPLIED_COUNT = if ($pattern.applied_count) { $pattern.applied_count } else { 0 }
+
+        Write-Host "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        Write-Host "🧠 LEARNED PATTERN #$idx: \`"$TITLE\`""
+        Write-Host "   Applied $APPLIED_COUNT time(s) with $SUCCESS_RATE success rate"
+        Write-Host "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        Write-Host ""
+    }
+}
+
+Write-Host "[ekkOS_LEARN] 🔥 FORGE new patterns when you solve something!"
+Write-Host ""
+
+exit 0
+`;
+}
+function generateStopHookPS(apiKey) {
+    return `# ekkOS Hook: Stop (Windows PowerShell)
+# Golden Loop: CAPTURE → MEASURE
+
+$ErrorActionPreference = "SilentlyContinue"
+
+$EKKOS_API_KEY = "${apiKey}"
+$MEMORY_API_URL = "https://mcp.ekkos.dev"
+$STATE_DIR = "$env:USERPROFILE\\.claude\\state"
+
+$INPUT = $input | Out-String
+$jsonInput = $INPUT | ConvertFrom-Json -ErrorAction SilentlyContinue
+
+$SESSION_ID = if ($jsonInput.session_id) { $jsonInput.session_id } else { "unknown" }
+$TIMESTAMP = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
+
+# Load patterns from RETRIEVE step
+$PATTERNS_FILE = "$STATE_DIR\\patterns-$SESSION_ID.json"
+$PATTERN_COUNT = 0
+$PATTERNS = @()
+
+if (Test-Path $PATTERNS_FILE) {
+    try {
+        $STORED_DATA = Get-Content $PATTERNS_FILE -Raw | ConvertFrom-Json
+        $PATTERNS = $STORED_DATA.patterns
+        $PATTERN_COUNT = if ($PATTERNS) { $PATTERNS.Count } else { 0 }
+    } catch {}
+}
+
+Write-Host ""
+Write-Host "[ekkOS_CAPTURE] ✓ Session saved"
+
+if ($PATTERN_COUNT -gt 0) {
+    Write-Host "[ekkOS_MEASURE] ✓ Tracked $PATTERN_COUNT patterns"
+}
+
+# Cleanup
+Remove-Item $PATTERNS_FILE -Force -ErrorAction SilentlyContinue
+
+Write-Host ""
+Write-Host "┌─────────────────────────────────────────────────────────────────┐"
+Write-Host "│  ekkOS_ GOLDEN LOOP COMPLETE                                    │"
+Write-Host "├─────────────────────────────────────────────────────────────────┤"
+Write-Host "│  The system learns from every interaction.                      │"
+Write-Host "└─────────────────────────────────────────────────────────────────┘"
+Write-Host ""
+
+exit 0
+`;
+}

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function status(): Promise<void>;