@ekkos/cli 1.3.1 → 1.3.2

package/templates/hooks-node/user-prompt-submit.js

@@ -1,337 +0,0 @@
-#!/usr/bin/env node
-/**
- * ═══════════════════════════════════════════════════════════════════════════
- * ekkOS_ Hook: UserPromptSubmit (Claude Code) - CAPTURE + RETRIEVE + INJECT
- * Node.js version - Works on Windows, macOS, Linux without bash dependencies
- *
- * ARCHITECTURE: Dumb Hook, Smart Backend
- * ═══════════════════════════════════════════════════════════════════════════
- */
-
-const https = require('https');
-const http = require('http');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-// Load state management
-const state = require('./lib/state');
-
-// ═══════════════════════════════════════════════════════════════════════════
-// ANSI Color Codes
-// ═══════════════════════════════════════════════════════════════════════════
-const CYAN = '\x1b[0;36m';
-const GREEN = '\x1b[0;32m';
-const YELLOW = '\x1b[1;33m';
-const MAGENTA = '\x1b[0;35m';
-const DIM = '\x1b[2m';
-const BOLD = '\x1b[1m';
-const RESET = '\x1b[0m';
-
-// ═══════════════════════════════════════════════════════════════════════════
-// HTTP Request Helper (uses built-in https module)
-// ═══════════════════════════════════════════════════════════════════════════
-function httpRequest(url, options, data) {
-  return new Promise((resolve, reject) => {
-    const urlObj = new URL(url);
-    const lib = urlObj.protocol === 'https:' ? https : http;
-    const timeout = options.timeout || 2000;
-
-    const req = lib.request({
-      hostname: urlObj.hostname,
-      port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
-      path: urlObj.pathname + urlObj.search,
-      method: options.method || 'GET',
-      headers: options.headers || {},
-      timeout: timeout
-    }, (res) => {
-      let body = '';
-      res.on('data', chunk => body += chunk);
-      res.on('end', () => {
-        try {
-          resolve(JSON.parse(body));
-        } catch {
-          resolve({ raw: body });
-        }
-      });
-    });
-
-    req.on('error', (e) => resolve({ error: e.message }));
-    req.on('timeout', () => {
-      req.destroy();
-      resolve({ error: 'timeout' });
-    });
-
-    if (data) req.write(typeof data === 'string' ? data : JSON.stringify(data));
-    req.end();
-  });
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Load Auth Token - PORTABLE: Check 3 sources in priority order
-// ═══════════════════════════════════════════════════════════════════════════
-function loadAuthToken() {
-  const homeDir = os.homedir();
-  const ekkosConfig = path.join(homeDir, '.ekkos', 'config.json');
-  let authToken = '';
-  let userId = '';
-
-  // 1. First try ~/.ekkos/config.json (set by VS Code extension - most portable)
-  //    Prefer hookApiKey (scoped key for hooks) over apiKey (legacy)
-  if (fs.existsSync(ekkosConfig)) {
-    try {
-      const config = JSON.parse(fs.readFileSync(ekkosConfig, 'utf8'));
-      authToken = config.hookApiKey || config.apiKey || '';
-      userId = config.userId || '';
-    } catch {}
-  }
-
-  // 2. Then try project .env.local (for developers with service role key)
-  if (!authToken) {
-    const envLocal = path.join(state.PROJECT_ROOT, '.env.local');
-    if (fs.existsSync(envLocal)) {
-      try {
-        const content = fs.readFileSync(envLocal, 'utf8');
-        const match = content.match(/^SUPABASE_SECRET_KEY=(.+)$/m);
-        if (match) {
-          authToken = match[1].replace(/["']/g, '').trim();
-        }
-      } catch {}
-    }
-  }
-
-  // 3. Finally try environment variable
-  if (!authToken) {
-    authToken = process.env.SUPABASE_SECRET_KEY || '';
-  }
-
-  return { authToken, userId };
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Main Hook Logic
-// ═══════════════════════════════════════════════════════════════════════════
-async function main() {
-  // Read JSON input from stdin
-  let inputData = '';
-  for await (const chunk of process.stdin) {
-    inputData += chunk;
-  }
-
-  let input;
-  try {
-    input = JSON.parse(inputData);
-  } catch {
-    process.exit(0);
-  }
-
-  const userQuery = input.query || input.message || input.prompt || '';
-  const sessionId = input.session_id || 'unknown';
-  const modelInfo = input.model || 'claude-sonnet-4-5';
-  const transcriptPath = input.transcript_path || '';
-
-  // Skip if empty
-  if (!userQuery) {
-    process.exit(0);
-  }
-
-  // Load auth
-  const { authToken, userId } = loadAuthToken();
-  const MEMORY_API_URL = 'https://mcp.ekkos.dev';
-
-  // Get current timestamp
-  const now = new Date();
-  const currentTime = now.toLocaleString('en-US', {
-    year: 'numeric',
-    month: '2-digit',
-    day: '2-digit',
-    hour: '2-digit',
-    minute: '2-digit',
-    hour12: true,
-    timeZoneName: 'short'
-  });
-
-  // Visual header
-  console.log('');
-  console.log(`${CYAN}${BOLD}🧠 ekkOS Memory${RESET} ${DIM}| Claude Code (${modelInfo}) | ${currentTime}${RESET}`);
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // [ekkOS_CAPTURE] Capture the PREVIOUS exchange before processing new one
-  // ═══════════════════════════════════════════════════════════════════════════
-  if (state.acquireLock(sessionId)) {
-    if (transcriptPath && fs.existsSync(transcriptPath)) {
-      try {
-        const transcriptContent = fs.readFileSync(transcriptPath, 'utf8');
-        const lines = transcriptContent.split('\n').filter(Boolean).map(l => {
-          try { return JSON.parse(l); } catch { return null; }
-        }).filter(Boolean);
-
-        // Get human messages
-        const humanMsgs = lines.filter(l => l.type === 'human');
-        const assistantMsgs = lines.filter(l => l.type === 'assistant');
-
-        // Get second-to-last human message (the previous query, not current)
-        const prevUser = humanMsgs.length > 1 ? humanMsgs[humanMsgs.length - 2]?.message : null;
-
-        // Get last assistant response
-        const lastAssistant = assistantMsgs[assistantMsgs.length - 1];
-        let prevAssistant = '';
-        if (lastAssistant?.message?.content) {
-          if (Array.isArray(lastAssistant.message.content)) {
-            prevAssistant = lastAssistant.message.content
-              .filter(c => c.type === 'text')
-              .map(c => c.text)
-              .join(' ');
-          } else {
-            prevAssistant = lastAssistant.message.content;
-          }
-        }
-
-        // Capture if we have both
-        if (prevUser && prevAssistant) {
-          const prevHash = state.generateTurnHash(prevUser, prevAssistant);
-
-          if (!state.wasTurnCaptured(sessionId, prevHash)) {
-            // Capture in background (don't wait)
-            httpRequest(`${MEMORY_API_URL}/api/v1/memory/capture`, {
-              method: 'POST',
-              headers: {
-                'Authorization': `Bearer ${authToken}`,
-                'Content-Type': 'application/json'
-              },
-              timeout: 5000
-            }, {
-              user_query: prevUser,
-              assistant_response: prevAssistant,
-              session_id: `claude-code-${sessionId}`,
-              metadata: {
-                source: 'claude-code-hook-node',
-                model_used: modelInfo,
-                captured_at: new Date().toISOString()
-              }
-            }).catch(() => {});
-
-            state.markTurnCaptured(sessionId, prevHash);
-            console.log(`${CYAN}   💾 Capture${RESET} ${DIM}saving previous turn${RESET}`);
-          }
-        }
-      } catch {}
-    }
-    state.releaseLock(sessionId);
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // [ekkOS_RETRIEVE] Single API call - backend handles ALL the work
-  // ═══════════════════════════════════════════════════════════════════════════
-  console.log(`${MAGENTA}   🔍 Retrieve${RESET} ${DIM}searching memory substrate...${RESET}`);
-
-  let apiResponse;
-  if (!authToken) {
-    console.log(`${DIM}   ⚠️  Retrieve${RESET} ${DIM}skipped (no auth)${RESET}`);
-    apiResponse = { error: 'no_auth', formatted_context: '', layers: { patterns: [], directives: [] } };
-  } else {
-    apiResponse = await httpRequest(`${MEMORY_API_URL}/api/v1/context/retrieve`, {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${authToken}`,
-        'Content-Type': 'application/json'
-      },
-      timeout: 1500
-    }, {
-      query: userQuery,
-      user_id: userId || 'system',
-      session_id: `claude-code-${sessionId}`,
-      max_per_layer: 5,
-      include_layers: ['working', 'episodic', 'semantic', 'patterns', 'procedural', 'collective', 'codebase', 'directives'],
-      metadata: {
-        source: 'claude-code-node',
-        model_used: modelInfo
-      }
-    });
-
-    if (!apiResponse.layers) {
-      apiResponse = { error: 'timeout', formatted_context: '', layers: { patterns: [], directives: [] } };
-    }
-  }
-
-  // Extract counts
-  const layers = apiResponse.layers || {};
-  const patternCount = (layers.patterns || []).length;
-  const directiveCount = (layers.directives || []).length;
-  const episodicCount = (layers.episodic || []).length;
-  const proceduralCount = (layers.procedural || []).length;
-  const codebaseCount = (layers.codebase || []).length;
-  const totalCount = patternCount + directiveCount + episodicCount + proceduralCount + codebaseCount;
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // [ekkOS_INJECT] Output the formatted context
-  // ═══════════════════════════════════════════════════════════════════════════
-  if (totalCount > 0) {
-    console.log(`${GREEN}   ✨ Inject${RESET}  ${GREEN}${totalCount}${RESET} ${DIM}memories loaded (${patternCount} patterns, ${directiveCount} directives)${RESET}`);
-    console.log('');
-
-    const formatted = apiResponse.formatted_context;
-    if (formatted) {
-      console.log(formatted);
-    } else {
-      // Fallback: structured output
-      if (patternCount > 0) {
-        console.log('## Pattern Memory (Layer 4) - Directive Compliant');
-        console.log('Proven solutions:');
-        for (const p of layers.patterns.slice(0, 5)) {
-          console.log(`${p.title || 'Untitled'}`);
-          console.log(`   Problem: ${(p.problem || 'N/A').substring(0, 200)}`);
-          console.log(`   Solution: ${(p.solution || 'N/A').substring(0, 300)}`);
-          console.log(`   Success Rate: ${p.success_rate || 0}%`);
-          console.log('');
-        }
-      }
-
-      if (directiveCount > 0) {
-        console.log('## Directive Memory (Layer 9) - HIGHEST PRIORITY');
-        console.log('User rules that MUST be followed:');
-        for (const d of layers.directives.slice(0, 5)) {
-          console.log(`   [${d.type || 'PREFER'}] ${d.rule || d.content || 'No rule'}`);
-        }
-        console.log('');
-      }
-
-      if (proceduralCount > 0) {
-        console.log('## Procedural Memory (Layer 5)');
-        console.log('Multi-step workflows:');
-        for (const p of layers.procedural.slice(0, 3)) {
-          console.log(`   • ${p.title || p.name || 'Workflow'}`);
-        }
-        console.log('');
-      }
-
-      if (episodicCount > 0) {
-        console.log('## Episodic Memory (Layer 2)');
-        console.log('Similar past conversations:');
-        for (const e of layers.episodic.slice(0, 3)) {
-          console.log(`   • ${(e.query_preview || e.problem || 'Previous session').substring(0, 100)}...`);
-        }
-        console.log('');
-      }
-
-      if (codebaseCount > 0) {
-        console.log('## Codebase Memory (Layer 8)');
-        console.log('Project-specific knowledge:');
-        for (const c of layers.codebase.slice(0, 3)) {
-          console.log(`   • ${c.file_path || c.title || 'Code pattern'}`);
-        }
-        console.log('');
-      }
-    }
-  } else {
-    console.log(`${DIM}   📭 Inject${RESET}  ${DIM}no matching patterns found${RESET}`);
-    console.log('');
-  }
-
-  // Save patterns for stop.js
-  state.savePatterns(sessionId, layers.patterns || [], modelInfo);
-
-  process.exit(0);
-}
-
-main().catch(() => process.exit(0));

package/templates/rules/00-hooks-contract.mdc

@@ -1,89 +0,0 @@
----
-priority: 100
-globs: ["**/*"]
-alwaysApply: true
----
-
-# 🔒 Cursor Hooks Contract
-
-⚠️ **MANDATORY**: Hooks run automatically - you don't call them manually
-
-## Hook Architecture
-
-**Dumb Hooks, Smart Backend** - Hooks just capture data, backend does analysis
-
-### user-prompt-submit.sh (Runs BEFORE Response)
-
-**Triggers**: When user sends a message
-**Does**:
-
-- Captures start time
-- Retrieves patterns from MCP gateway (automatic)
-- Displays patterns to user
-- Saves patterns to `.cursor/state/` for badge
-
-**You see**:
-
-```
-🧠 ekkOS™_Retrieving [18ms]
-✓ 3 patterns loaded from memory
-```
-
-### stop.sh (Runs AFTER Response)
-
-**Triggers**: When your response completes
-**Does**:
-
-- Captures conversation to memory API
-- Generates badge with metrics
-- Triggers async analysis (pattern detection, success judgment)
-- Displays badge at end
-
-**You see**:
-
-```
-[ekkOS_CAPTURE] ✓ Saved (ID: abc123...)
-[reflex:uuid] badge
-```
-
-## What You Do
-
-**✅ DO**:
-
-- Display `_ekkos_stream_message` when present in tool responses
-- Call `forge_insight` when solving problems
-- Show ekkOS branded messages
-
-**❌ DON'T**:
-
-- Manually call capture scripts (hooks do this)
-- Generate badges yourself (hooks do this)
-- Worry about pattern retrieval (MCP gateway does this)
-
-## Hook Flow
-
-```
-User sends message
-    ↓
-user-prompt-submit.sh runs
-    ↓
-Patterns retrieved and displayed
-    ↓
-You respond (using patterns)
-    ↓
-stop.sh runs
-    ↓
-Conversation captured + badge generated
-```
-
-## Trust the Hooks
-
-Hooks are:
-
-- ✅ Fully portable (POSIX-compliant)
-- ✅ Bulletproof (fallbacks for missing tools)
-- ✅ Fast (non-blocking, cloud-first)
-- ✅ Automatic (you never call them)
-
-**Your job**: Use the patterns hooks provide, forge insights when you solve problems
-

package/templates/rules/30-ekkos-core.mdc

@@ -1,188 +0,0 @@
----
-priority: 100
-globs: ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"]
----
-
-# 🧠 ekkOS™ Memory Integration [CRITICAL]
-
-## Golden Loop Enforcement
-
-⚠️ MANDATORY WORKFLOW - NO EXCEPTIONS
-
-### Phase 1: RETRIEVE (⚠️ CURSOR: YOU MUST DO THIS)
-
-🔴 **FIRST THING EVERY RESPONSE**: Call `ekkOS_Search` with the user's query!
-
-```typescript
-// ALWAYS call this BEFORE doing anything else
-mcp__ekkos-memory__ekkOS_Search({
-  query: "<user's question or task>",
-  limit: 5
-})
-```
-
-Then check response for: `_ekkos_patterns`, `_ekkos_stream_message`
-
-**Why?** Cursor has no hooks. Claude Code auto-retrieves via hooks - you don't.
-You MUST manually retrieve or the Golden Loop breaks.
-
-### Phase 2: APPLY (Use Retrieved Patterns)
-
-When patterns found → Apply them (PROVEN solutions, not suggestions)
-Output: `[ekkOS_APPLY] Using pattern: "Pattern Name"`
-
-### Phase 3: MEASURE (Track Outcomes)
-
-Pattern worked? → success | Pattern failed? → failure
-Output: `[ekkOS_MEASURE] Pattern "X" outcome: success/failure`
-
-### Phase 4: LEARN (Forge New Patterns)
-
-🔴 MANDATORY: Call `forge_insight` when you solve ANY problem
-
-**When to forge**:
-
-- Fixed bug (non-obvious) → forge
-- Found better approach → forge
-- Discovered gotcha/pitfall → forge
-- User corrected you → forge
-- Solved problem (>1 attempt) → forge
-
-**Tool call**:
-
-```typescript
-mcp__ekkos-memory__forge_insight({
-  title: "Clear Title",
-  problem: "What failed?",
-  solution: "How you fixed it",
-  tags: ["tech", "tags"],
-});
-```
-
-Output: `[ekkOS_LEARN] Forged: "Pattern Title"`
-
-### Phase 5: CAPTURE (Cursor: Limited)
-
-⚠️ **Cursor limitation**: No automatic capture like Claude Code hooks.
-Conversations are captured when MCP tools are called (search_memory, forge_insight).
-For full capture, use Claude Code or the ekkOS dashboard.
-
-## MCP Tools (31 Total - YOU call these)
-
-### 🔴 MANDATORY - Use Proactively
-
-| Tool | Trigger | Description |
-|------|---------|-------------|
-| `ekkOS_Search` | Before ANY technical question | Search all 11 memory layers |
-| `ekkOS_Forge` | When you fix bug, learn, get corrected | Create pattern from solution |
-| `ekkOS_Directive` | User says "always/never/prefer/avoid" | Create MUST/NEVER/PREFER/AVOID rules |
-| `ekkOS_Outcome` | Pattern worked or failed | Track success/failure |
-| `ekkOS_Detect` | After responding | Auto-detect patterns used |
-| `ekkOS_Summary` | Show MCP activity | Get activity summary |
-| `ekkOS_Conflict` | Before destructive action | Check for conflicts |
-| `ekkOS_Reflect` | Analyze response quality | Find improvement opportunities |
-
-### 📚 Recall & Context
-
-| Tool | Description |
-|------|-------------|
-| `ekkOS_Recall` | "What did we discuss yesterday?" |
-| `ekkOS_Context` | Get task-specific context |
-| `ekkOS_Codebase` | Find code patterns in project |
-| `ekkOS_Capture` | Manual event capture |
-| `ekkOS_Track` | Track pattern application |
-| `ekkOS_Stats` | Memory layer statistics |
-
-### 📊 Schema Awareness
-
-| Tool | Description |
-|------|-------------|
-| `ekkOS_IndexSchema` | Index database schemas (Supabase/Prisma/TS) |
-| `ekkOS_GetSchema` | Get schema for a specific table/type |
-
-### 📋 Plan Management
-
-| Tool | Description |
-|------|-------------|
-| `ekkOS_Plan` | Create structured plan |
-| `ekkOS_Plans` | List user's plans |
-| `ekkOS_PlanStatus` | Change plan state |
-| `ekkOS_PlanStep` | Mark step complete |
-| `ekkOS_Generate` | AI-generate plan |
-| `ekkOS_SaveTemplate` | Save as reusable template |
-| `ekkOS_Templates` | List templates |
-| `ekkOS_FromTemplate` | Create from template |
-
-### 🔐 Secrets Management
-
-| Tool | Description |
-|------|-------------|
-| `ekkOS_StoreSecret` | Encrypt and store credentials |
-| `ekkOS_GetSecret` | Retrieve and decrypt |
-| `ekkOS_ListSecrets` | List metadata (no values) |
-| `ekkOS_DeleteSecret` | Permanently delete |
-| `ekkOS_RotateSecret` | Update with new value |
-
-### 💾 Portability
-
-| Tool | Description |
-|------|-------------|
-| `ekkOS_Export` | Backup patterns, directives, plans |
-| `ekkOS_Import` | Restore from backup |
-
-## Proactive Tool Triggers
-
-### Always Use `ekkOS_Search` When:
-- User asks technical question
-- User mentions past discussion
-- Topic involves architecture, config, debugging
-- You're about to make a decision
-
-### Always Use `ekkOS_Forge` When:
-- Fixed bug (especially non-obvious)
-- Discovered better approach
-- Found pitfall or gotcha
-- User corrected you
-- Made architectural decision
-- Something DIDN'T work (anti-pattern)
-
-### Always Use `ekkOS_Directive` When:
-- User says "always..." → MUST
-- User says "never..." → NEVER
-- User says "I prefer..." → PREFER
-- User says "don't..." → AVOID
-
-### Always Use `ekkOS_Conflict` When:
-- About to delete files/data
-- About to deploy to production
-- About to modify config files
-
-## Enforcement
-
-⚠️ Violating Golden Loop = System failure
-Every conversation MUST follow: RETRIEVE → APPLY → MEASURE → LEARN → CAPTURE
-
----
-
-## 🔴 MANDATORY RESPONSE FORMAT (NO EXCEPTIONS)
-
-**Every response MUST end with a timestamp footer:**
-
-```
----
-🧠 **ekkOS_™** · 📅 YYYY-MM-DD H:MM AM/PM TZ
-```
-
-**Example:**
-```
----
-🧠 **ekkOS_™** · 📅 2025-12-08 2:30 PM PST
-```
-
-**Why this matters:**
-- Timestamps track when patterns were applied
-- 3-Judge evaluations need temporal context
-- Future agents can trace learning timeline
-- Golden Loop metrics require time-based correlation
-
-**⚠️ MISSING TIMESTAMP = INCOMPLETE LOOP = SYSTEM DEGRADATION**

package/templates/rules/31-ekkos-messages.mdc

@@ -1,78 +0,0 @@
----
-priority: 100
-globs: ["**/*"]
----
-
-# ekkOS™ Branded Message Templates
-
-## Stream Message Fields (Display All Present)
-
-```
-_ekkos_stream_message     → Display FIRST (🧠 Retrieving/🔄 Applying/✅ Learned)
-_ekkos_learning_message   → Display AFTER solution (🔥 Learning - pattern detected)
-_ekkos_session_summary    → Display AT END (📊 Summary at turns 5/10/20/50)
-```
-
-## Message Examples
-
-### Before Response:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🧠 ekkOS™_Retrieving [18ms]
-✓ 3 patterns loaded from memory
-  • "Pattern Name" (94% success, 12 uses)
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-### When Learning:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🔥 ekkOS™_Learning
-New pattern detected: "Title"
-Confidence: 60% (forming)
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-### When Pattern Saved:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-✅ ekkOS™_Learned
-Pattern saved: "Title"
-Confidence: 85% | Success: 100%
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-### When Reusing:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🔄 ekkOS™_Applying
-Using pattern from 2 messages ago
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-### Session Summary:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-📊 ekkOS™_Session_Summary
-Memory Activity:
-  Retrieved: 5 patterns
-  Applied: 3 patterns
-  Learned: 2 new patterns
-  Confidence: +8% overall
-
-Your AI is getting smarter.
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-## Requirements
-
-- ALWAYS use ekkOS™ branding (with ™)
-- ALWAYS show retrieval before response
-- ALWAYS show learning when it happens
-- Keep messages concise but visible
-