claude-mem 2.1.2 → 3.0.2

package/hooks/session-start.js

@@ -1,75 +1,190 @@
 #!/usr/bin/env node
 
 /**
- * Claude Memory System - Session-Start Hook (Refactored)
- * Uses shared utilities to eliminate code duplication
+ * 🔒 LOCKED by @docs-agent | Change to 🔑 to allow @docs-agent edits
  * 
- * Always loads context regardless of source (startup/compact/vscode/web)
+ * OFFICIAL DOCS: Claude Code SessionStart Hook v2025
+ * Last Verified: 2025-08-31
+ * @see https://docs.anthropic.com/en/docs/claude-code/hooks
+ * 
+ * SessionStart Hook Payload:
+ * {
+ *   "session_id": "string",
+ *   "transcript_path": "string",
+ *   "hook_event_name": "SessionStart",
+ *   "source": "startup" | "compact" | "vscode" | "web"
+ * }
+ * 
+ * The 'source' field indicates how the session was initiated:
+ * - "startup": New session started normally
+ * - "compact": Session started after compaction
+ * - "vscode": Session initiated from VS Code
+ * - "web": Session initiated from web interface
+ * 
+ * Valid Response Format:
+ * Success without context: { "continue": true }
+ * Success with context: {
+ *   "continue": true,
+ *   "hookSpecificOutput": {
+ *     "hookEventName": "SessionStart",
+ *     "additionalContext": "string"  // Context to add to session
+ *   }
+ * }
+ * Failure: { "continue": false, "stopReason": "error message" }
+ * 
+ * @docs-ref: SessionStart supports hookSpecificOutput.additionalContext
+ * @see https://docs.anthropic.com/claude-code/hooks#sessionstart
  */
 
-import { loadHookConfig, readStdinJson, HookResponse, spawnCLI } from './hook-utils.js';
-import { dirname, basename } from 'path';
+import { spawn } from 'child_process';
+import { join, dirname, basename } from 'path';
+import { fileURLToPath } from 'url';
+import { readFileSync, existsSync } from 'fs';
 
-async function sessionStartHook() {
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Load configuration to get the CLI command name
+let cliCommand = 'claude-mem';  // Default fallback
+const configPath = join(__dirname, 'config.json');
+if (existsSync(configPath)) {
   try {
-    // Load config and read input using utilities
-    const config = loadHookConfig();
-    const data = await readStdinJson();
-    
-    // Extract project name from transcript path if available
-    let projectName = null;
-    if (data.transcript_path) {
-      const dir = dirname(data.transcript_path);
-      const dirName = basename(dir);
+    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+    cliCommand = config.cliCommand || 'claude-mem';
+  } catch (e) {
+    // Fallback to default if config read fails
+  }
+}
+
+async function sessionStartHook() {
+  let input = '';
+  
+  // Read JSON input from stdin
+  process.stdin.on('data', chunk => {
+    input += chunk;
+  });
+  
+  process.stdin.on('end', async () => {
+    try {
+      const data = JSON.parse(input);
+      
+      /**
+       * @docs-ref: SessionStart payload includes 'source' field
+       * See: https://docs.anthropic.com/en/docs/claude-code/hooks#sessionstart
+       * 
+       * The 'source' field indicates the session start context:
+       * - 'startup': New session (load context)
+       * - 'compact': Session after compaction (SHOULD load context)
+       * - 'vscode': VS Code initiated session
+       * - 'web': Web interface initiated session
+       * 
+       * IMPORTANT: We always load context regardless of source.
+       * After compaction, users expect to see their compressed memories loaded.
+       * The session after compact is effectively a new session with compressed context.
+       * 
+       * There is no specific indicator for /continue command in the payload,
+       * so we treat all session starts equally and load available context.
+       */
+      // Always proceed to load context for all session types
       
-      // Extract project name from directory pattern
-      if (dirName.includes('-Scripts-')) {
-        const parts = dirName.split('-Scripts-');
-        if (parts.length > 1) {
-          projectName = parts[1];
+      // Extract project name from transcript path if available
+      let projectName = null;
+      if (data.transcript_path) {
+        const dir = dirname(data.transcript_path);
+        const dirName = basename(dir);
+        
+        // Extract project name from directory pattern
+        if (dirName.includes('-Scripts-')) {
+          const parts = dirName.split('-Scripts-');
+          if (parts.length > 1) {
+            projectName = parts[1];
+          }
+        } else {
+          projectName = dirName;
+        }
+        
+        // Sanitize project name to match what compression uses
+        // This ensures we match the exact project name in the index
+        if (projectName) {
+          projectName = projectName.replace(/[^a-zA-Z0-9]/g, '_');
         }
-      } else {
-        projectName = dirName;
       }
       
-      // Sanitize project name to match what compression uses
+      // Build command to run
+      const args = ['load-context', '--format', 'session-start'];
+      
+      // Add project filter if we have a project name
       if (projectName) {
-        projectName = projectName.replace(/[^a-zA-Z0-9]/g, '_');
+        args.push('--project', projectName);
       }
-    }
-    
-    // Build command to run
-    const args = ['load-context', '--format', 'session-start'];
-    if (projectName) {
-      args.push('--project', projectName);
-    }
-    
-    // Use spawnCLI utility for loading context
-    const cliCommand = config.cliCommand || 'claude-mem';
-    
-    try {
-      const result = await spawnCLI(cliCommand, args);
       
-      // Output the formatted context if we have any
-      if (result.stdout && result.stdout.trim()) {
-        console.log(JSON.stringify(HookResponse.success("SessionStart", result.stdout)));
-      } else {
-        console.log(JSON.stringify({ continue: true }));
-      }
+      // Call the CLI load-context command directly
+      // Use the configured CLI command name (claude-mem)
+      // This ensures we use the correct version with full summaries
+      const loader = spawn(cliCommand, args, {
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+      
+      let stdout = '';
+      let stderr = '';
+      
+      loader.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+      
+      loader.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+      
+      loader.on('close', (code) => {
+        if (code !== 0) {
+          // If load-context fails, just continue without context
+          // This could happen if no index exists yet
+          // @docs-ref: Always return valid response format
+          console.log(JSON.stringify({
+            continue: true
+          }));
+          process.exit(0);
+        }
+        
+        // Output the formatted context for Claude to see using proper JSON format
+        // @docs-ref: SessionStart supports hookSpecificOutput.additionalContext
+        if (stdout && stdout.trim()) {
+          console.log(JSON.stringify({
+            continue: true,
+            hookSpecificOutput: {
+              hookEventName: "SessionStart",
+              additionalContext: stdout
+            }
+          }));
+        } else {
+          // No context to add, just continue
+          console.log(JSON.stringify({
+            continue: true
+          }));
+        }
+        
+        process.exit(0);
+      });
+      
+      loader.on('error', () => {
+        // If there's an error running the command, continue without context
+        // We don't want to break the session start
+        // @docs-ref: Always return valid response format
+        console.log(JSON.stringify({
+          continue: true
+        }));
+        process.exit(0);
+      });
       
     } catch (error) {
-      // If load-context fails, just continue without context
-      // This could happen if no index exists yet
-      console.log(JSON.stringify({ continue: true }));
+      // Any errors, just continue without additional context
+      // @docs-ref: Always return valid response format
+      console.log(JSON.stringify({
+        continue: true
+      }));
+      process.exit(0);
     }
-    
-    process.exit(0);
-    
-  } catch (error) {
-    // Any errors, just continue without additional context
-    console.log(JSON.stringify({ continue: true }));
-    process.exit(0);
-  }
+  });
 }
 
 sessionStartHook();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem",
-  "version": "2.1.2",
+  "version": "3.0.2",
   "description": "Memory compression system for Claude Code - persist context across sessions",
   "keywords": [
     "claude",