clawvault 1.6.0 → 1.6.1

package/hooks/clawvault/HOOK.md

@@ -1,10 +1,10 @@
 ---
 name: clawvault
-description: "Context death resilience - auto-checkpoint and recovery detection"
+description: "Context resilience - recovery detection, auto-checkpoint, and session context injection"
 metadata:
   openclaw:
     emoji: "🐘"
-    events: ["gateway:startup", "command:new"]
+    events: ["gateway:startup", "command:new", "session:start"]
     requires:
       bins: ["clawvault"]
 ---
@@ -15,6 +15,7 @@ Integrates ClawVault's context death resilience into OpenClaw:
 
 - **On gateway startup**: Checks for context death, alerts agent
 - **On /new command**: Auto-checkpoints before session reset
+- **On session start**: Injects relevant vault context for the initial prompt
 
 ## Installation
 
@@ -43,6 +44,20 @@ openclaw hooks enable clawvault
 2. Captures state even if agent forgot to handoff
 3. Ensures continuity across session resets
 
+### Session Start
+
+1. Extracts the initial user prompt (`context.initialPrompt` or first user message)
+2. Runs `clawvault context "<prompt>" --format json`
+3. Injects up to 4 relevant context bullets into session messages
+
+Injection format:
+
+```text
+[ClawVault] Relevant context for this task:
+- <title> (<age>): <snippet>
+- <title> (<age>): <snippet>
+```
+
 ## No Configuration Needed
 
 Just enable the hook. It auto-detects vault path via:

package/hooks/clawvault/handler.js

@@ -4,6 +4,7 @@
  * Provides automatic context death resilience:
  * - gateway:startup → detect context death, inject recovery info
  * - command:new → auto-checkpoint before session reset
+ * - session:start → inject relevant context for first user prompt
  * 
  * SECURITY: Uses execFileSync (no shell) to prevent command injection
  */
@@ -12,6 +13,10 @@ import { execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 
+const MAX_CONTEXT_RESULTS = 4;
+const MAX_CONTEXT_PROMPT_LENGTH = 500;
+const MAX_CONTEXT_SNIPPET_LENGTH = 220;
+
 // Sanitize string for safe display (prevent prompt injection via control chars)
 function sanitizeForDisplay(str) {
   if (typeof str !== 'string') return '';
@@ -22,6 +27,126 @@ function sanitizeForDisplay(str) {
     .slice(0, 200);                   // Limit length
 }
 
+// Sanitize prompt before passing to CLI command
+function sanitizePromptForContext(str) {
+  if (typeof str !== 'string') return '';
+  return str
+    .replace(/[\x00-\x1f\x7f]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, MAX_CONTEXT_PROMPT_LENGTH);
+}
+
+function extractTextFromMessage(message) {
+  if (typeof message === 'string') return message;
+  if (!message || typeof message !== 'object') return '';
+
+  const content = message.content ?? message.text ?? message.message;
+  if (typeof content === 'string') return content;
+
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === 'string') return part;
+        if (!part || typeof part !== 'object') return '';
+        if (typeof part.text === 'string') return part.text;
+        if (typeof part.content === 'string') return part.content;
+        return '';
+      })
+      .filter(Boolean)
+      .join(' ');
+  }
+
+  return '';
+}
+
+function isUserMessage(message) {
+  if (typeof message === 'string') return true;
+  if (!message || typeof message !== 'object') return false;
+  const role = typeof message.role === 'string' ? message.role.toLowerCase() : '';
+  const type = typeof message.type === 'string' ? message.type.toLowerCase() : '';
+  return role === 'user' || role === 'human' || type === 'user';
+}
+
+function extractInitialPrompt(event) {
+  const fromContext = sanitizePromptForContext(event?.context?.initialPrompt);
+  if (fromContext) return fromContext;
+
+  const candidates = [
+    event?.context?.messages,
+    event?.context?.initialMessages,
+    event?.context?.history,
+    event?.messages
+  ];
+
+  for (const list of candidates) {
+    if (!Array.isArray(list)) continue;
+    for (const message of list) {
+      if (!isUserMessage(message)) continue;
+      const text = sanitizePromptForContext(extractTextFromMessage(message));
+      if (text) return text;
+    }
+  }
+
+  return '';
+}
+
+function truncateSnippet(snippet) {
+  const safe = sanitizeForDisplay(snippet).replace(/\s+/g, ' ').trim();
+  if (safe.length <= MAX_CONTEXT_SNIPPET_LENGTH) return safe;
+  return `${safe.slice(0, MAX_CONTEXT_SNIPPET_LENGTH - 3).trimEnd()}...`;
+}
+
+function parseContextJson(output) {
+  try {
+    const parsed = JSON.parse(output);
+    if (!parsed || !Array.isArray(parsed.context)) return [];
+
+    return parsed.context
+      .slice(0, MAX_CONTEXT_RESULTS)
+      .map((entry) => ({
+        title: sanitizeForDisplay(entry?.title || 'Untitled'),
+        age: sanitizeForDisplay(entry?.age || 'unknown age'),
+        snippet: truncateSnippet(entry?.snippet || '')
+      }))
+      .filter((entry) => entry.snippet);
+  } catch {
+    return [];
+  }
+}
+
+function formatContextInjection(entries) {
+  const lines = ['[ClawVault] Relevant context for this task:'];
+  for (const entry of entries) {
+    lines.push(`- ${entry.title} (${entry.age}): ${entry.snippet}`);
+  }
+  return lines.join('\n');
+}
+
+function injectSystemMessage(event, message) {
+  if (!event.messages || !Array.isArray(event.messages)) return false;
+
+  if (event.messages.length === 0) {
+    event.messages.push(message);
+    return true;
+  }
+
+  const first = event.messages[0];
+  if (first && typeof first === 'object' && !Array.isArray(first)) {
+    if ('role' in first || 'content' in first) {
+      event.messages.push({ role: 'system', content: message });
+      return true;
+    }
+    if ('type' in first || 'text' in first) {
+      event.messages.push({ type: 'system', text: message });
+      return true;
+    }
+  }
+
+  event.messages.push(message);
+  return true;
+}
+
 // Validate vault path - must be absolute and exist
 function validateVaultPath(vaultPath) {
   if (!vaultPath || typeof vaultPath !== 'string') return null;
@@ -151,11 +276,9 @@ async function handleStartup(event) {
     const alertMsg = alertParts.join(' ');
 
     // Inject into event messages if available
-    if (event.messages && Array.isArray(event.messages)) {
-      event.messages.push(alertMsg);
+    if (injectSystemMessage(event, alertMsg)) {
+      console.warn('[clawvault] Context death detected, alert injected');
     }
-    
-    console.warn('[clawvault] Context death detected, alert injected');
   } else {
     console.log('[clawvault] Clean startup - no context death');
   }
@@ -194,6 +317,47 @@ async function handleNew(event) {
   }
 }
 
+// Handle session start - inject dynamic context for first prompt
+async function handleSessionStart(event) {
+  const vaultPath = findVaultPath();
+  if (!vaultPath) {
+    console.log('[clawvault] No vault found, skipping context injection');
+    return;
+  }
+
+  const prompt = extractInitialPrompt(event);
+  if (!prompt) {
+    console.log('[clawvault] No initial prompt, skipping context injection');
+    return;
+  }
+
+  console.log('[clawvault] Fetching context for session start');
+
+  const result = runClawvault([
+    'context',
+    prompt,
+    '--format', 'json',
+    '-v', vaultPath
+  ]);
+
+  if (!result.success) {
+    console.warn('[clawvault] Context lookup failed');
+    return;
+  }
+
+  const entries = parseContextJson(result.output);
+  if (entries.length === 0) {
+    console.log('[clawvault] No relevant context found for prompt');
+    return;
+  }
+
+  if (injectSystemMessage(event, formatContextInjection(entries))) {
+    console.log(`[clawvault] Injected ${entries.length} context item(s)`);
+  } else {
+    console.log('[clawvault] No message array available, skipping injection');
+  }
+}
+
 // Main handler - route events
 const handler = async (event) => {
   try {
@@ -206,6 +370,11 @@ const handler = async (event) => {
       await handleNew(event);
       return;
     }
+
+    if (event.type === 'session' && event.action === 'start') {
+      await handleSessionStart(event);
+      return;
+    }
   } catch (err) {
     console.error('[clawvault] Hook error:', err.message || 'unknown error');
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawvault",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "🐘 An elephant never forgets. Structured memory for OpenClaw agents. Context death resilience, Obsidian-compatible markdown, local semantic search.",
   "type": "module",
   "main": "dist/index.cjs",