claude-mem 2.0.9 → 2.1.1

package/hooks/hook-utils.js

@@ -0,0 +1,318 @@
+/**
+ * Shared utilities for Claude Code hooks
+ * 
+ * This module provides common functionality for all hook files to eliminate
+ * duplicated code patterns across pre-compact.js, session-start.js, etc.
+ */
+
+import { spawn } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+// Import constants - note: hooks are JavaScript, not TypeScript
+const PACKAGE_NAME = 'claude-mem';
+const CLAUDE_MEM_BASE = '.claude-mem';
+
+// =============================================================================
+// HOOK CONFIGURATION LOADING
+// =============================================================================
+
+/**
+ * Load hook configuration from settings (eliminates ~33 lines per hook)
+ */
+export function loadHookConfig() {
+  const settingsPath = join(homedir(), CLAUDE_MEM_BASE, 'settings.json');
+  
+  if (!existsSync(settingsPath)) {
+    return {};
+  }
+  
+  try {
+    const content = readFileSync(settingsPath, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    console.warn(`Warning: Could not load hook config: ${error.message}`);
+    return {};
+  }
+}
+
+// =============================================================================
+// STDIN JSON READING
+// =============================================================================
+
+/**
+ * Read and parse JSON from stdin (removes 30+ duplicate lines)
+ * Returns a Promise that resolves with the parsed JSON data
+ */
+export function readStdinJson() {
+  return new Promise((resolve, reject) => {
+    let input = '';
+    
+    process.stdin.on('data', chunk => {
+      input += chunk;
+    });
+    
+    process.stdin.on('end', () => {
+      try {
+        const data = JSON.parse(input);
+        resolve(data);
+      } catch (error) {
+        reject(new Error(`Invalid JSON input: ${error.message}`));
+      }
+    });
+    
+    process.stdin.on('error', error => {
+      reject(new Error(`Stdin error: ${error.message}`));
+    });
+  });
+}
+
+// =============================================================================
+// HOOK RESPONSE HELPERS
+// =============================================================================
+
+/**
+ * Standard hook response objects (matches constants.ts HOOK_RESPONSES pattern)
+ */
+export const HookResponse = {
+  /**
+   * Success response with optional message (matches HOOK_RESPONSES.SUCCESS pattern)
+   */
+  success(hookEventName, message) {
+    return {
+      hookSpecificOutput: {
+        hookEventName,
+        status: "success",
+        message
+      },
+      suppressOutput: true
+    };
+  },
+
+  /**
+   * Skipped response (matches HOOK_RESPONSES.SKIPPED pattern)
+   */
+  skipped(hookEventName, message) {
+    return {
+      hookSpecificOutput: {
+        hookEventName,
+        status: "skipped",
+        message
+      },
+      suppressOutput: true
+    };
+  },
+
+  /**
+   * Error response (matches HOOK_RESPONSES.ERROR pattern)
+   */
+  error(hookEventName, message) {
+    return {
+      continue: false,
+      stopReason: message,
+      suppressOutput: true,
+      hookSpecificOutput: {
+        hookEventName,
+        status: "error",
+        message
+      }
+    };
+  },
+
+  /**
+   * Permission response for tool use
+   */
+  permission(decision, reason = '') {
+    return {
+      continue: true,
+      permissionDecision: decision, // 'allow' or 'deny'
+      permissionDecisionReason: reason
+    };
+  }
+};
+
+// =============================================================================
+// CLI SPAWNING UTILITIES
+// =============================================================================
+
+/**
+ * Spawn CLI command (consolidates 90+ lines of spawn logic)
+ */
+export function spawnCLI(command, args = [], options = {}) {
+  return new Promise((resolve, reject) => {
+    const defaultOptions = {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: process.env,
+      timeout: 30000, // 30 second default timeout
+      ...options
+    };
+
+    // Find CLI executable
+    const possibleCommands = [
+      PACKAGE_NAME,
+      `npx ${PACKAGE_NAME}`,
+      join(process.cwd(), 'node_modules', '.bin', PACKAGE_NAME),
+      join(homedir(), '.npm-global', 'bin', PACKAGE_NAME)
+    ];
+
+    let claudeMemCmd = command;
+    if (!claudeMemCmd) {
+      // Try to find the best command
+      claudeMemCmd = PACKAGE_NAME; // Default fallback
+    }
+
+    const child = spawn(claudeMemCmd, args, defaultOptions);
+    
+    let stdout = '';
+    let stderr = '';
+    
+    child.stdout?.on('data', (data) => {
+      stdout += data.toString();
+    });
+    
+    child.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+    
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve({
+          code,
+          stdout: stdout.trim(),
+          stderr: stderr.trim()
+        });
+      } else {
+        reject(new Error(`Command failed with code ${code}: ${stderr.trim()}`));
+      }
+    });
+    
+    child.on('error', (error) => {
+      reject(new Error(`Failed to spawn command: ${error.message}`));
+    });
+
+    // Handle timeout
+    if (defaultOptions.timeout) {
+      setTimeout(() => {
+        child.kill('SIGTERM');
+        reject(new Error(`Command timed out after ${defaultOptions.timeout}ms`));
+      }, defaultOptions.timeout);
+    }
+  });
+}
+
+/**
+ * Run CLI command with specific subcommand and arguments
+ */
+export async function runClaudeMemCommand(subcommand, args = [], options = {}) {
+  const fullArgs = [subcommand, ...args];
+  return spawnCLI(PACKAGE_NAME, fullArgs, options);
+}
+
+// =============================================================================
+// PROJECT NAME EXTRACTION
+// =============================================================================
+
+/**
+ * Extract project name from transcript path
+ * Consolidates the 3 different implementations found in the codebase
+ */
+export function extractProjectName(transcriptPath) {
+  if (!transcriptPath) {
+    return 'unknown';
+  }
+  
+  // Standard pattern: Scripts/[project-name]/...
+  const match = transcriptPath.match(/Scripts[\\/\\]([^\\/\\]+)/);
+  if (match) {
+    return match[1];
+  }
+  
+  // Fallback: try to extract from directory structure
+  const parts = transcriptPath.split(/[\\/]/);
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (parts[i] === 'Scripts' && parts[i + 1]) {
+      return parts[i + 1];
+    }
+  }
+  
+  return 'unknown';
+}
+
+// =============================================================================
+// UTILITY HELPERS
+// =============================================================================
+
+/**
+ * Safe JSON output for hook responses
+ */
+export function outputJSON(data) {
+  try {
+    console.log(JSON.stringify(data, null, 2));
+  } catch (error) {
+    console.error(JSON.stringify({
+      continue: false,
+      stopReason: `Failed to serialize response: ${error.message}`
+    }));
+  }
+}
+
+/**
+ * Debug logging helper
+ */
+export function debugLog(message) {
+  if (process.env.CLAUDE_MEM_DEBUG) {
+    console.error(`[DEBUG] ${message}`);
+  }
+}
+
+/**
+ * Validate hook payload structure
+ */
+export function validateHookPayload(payload, requiredFields = []) {
+  const errors = [];
+  
+  if (!payload || typeof payload !== 'object') {
+    errors.push('Payload must be an object');
+    return errors;
+  }
+  
+  requiredFields.forEach(field => {
+    if (!(field in payload)) {
+      errors.push(`Missing required field: ${field}`);
+    }
+  });
+  
+  return errors;
+}
+
+/**
+ * Create hook execution context
+ */
+export function createHookContext(payload) {
+  return {
+    sessionId: payload.session_id || 'unknown',
+    transcriptPath: payload.transcript_path || null,
+    hookEventName: payload.hook_event_name || 'unknown',
+    source: payload.source || 'unknown', // For SessionStart hooks
+    timestamp: new Date().toISOString(),
+    projectName: payload.transcript_path ? extractProjectName(payload.transcript_path) : null
+  };
+}
+
+// =============================================================================
+// EXPORT ALL UTILITIES
+// =============================================================================
+
+export default {
+  loadHookConfig,
+  readStdinJson,
+  HookResponse,
+  spawnCLI,
+  runClaudeMemCommand,
+  extractProjectName,
+  outputJSON,
+  debugLog,
+  validateHookPayload,
+  createHookContext
+};

package/hooks/pre-compact.js

@@ -1,138 +1,58 @@
 #!/usr/bin/env node
 
 /**
- * 🔒 LOCKED by @docs-agent | Change to 🔑 to allow @docs-agent edits
- * 
- * OFFICIAL DOCS: Claude Code Hooks API v2025
- * Last Verified: 2025-08-31
- * @see https://docs.anthropic.com/en/docs/claude-code/hooks
- * 
- * Claude Memory System - Pre-Compact Hook
- * 
- * CRITICAL REQUIREMENTS:
- * - Hook responses MUST use 'continue' field (boolean)
- * - When continue is false, MUST provide 'stopReason' field
- * - DO NOT use 'decision' or 'reason' fields (deprecated pattern)
- * - PreCompact hooks DO NOT support hookSpecificOutput field
- * - Exit codes: 0=success, 1=error shown to user, 2=error with stderr shown
- * 
- * Valid Response Format:
- * Success: { "continue": true }
- * Failure: { "continue": false, "stopReason": "error message" }
- * 
- * @docs-ref: Official hook response format specification
- * @see https://docs.anthropic.com/claude-code/hooks#response-format
+ * Claude Memory System - Pre-Compact Hook (Refactored)
+ * Uses shared utilities to eliminate code duplication
  */
 
-import { spawn } from 'child_process';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { readFileSync, existsSync } from 'fs';
-
-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 {
-    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
-    cliCommand = config.cliCommand || 'claude-mem';
-  } catch (e) {
-    // Fallback to default if config read fails
-  }
-}
+import { loadHookConfig, readStdinJson, HookResponse, spawnCLI } from './hook-utils.js';
 
 async function preCompactHook() {
-  let input = '';
-  
-  // Read JSON input from stdin
-  process.stdin.on('data', chunk => {
-    input += chunk;
-  });
-  
-  process.stdin.on('end', async () => {
+  try {
+    // Load config and read input using utilities
+    const config = loadHookConfig();
+    const data = await readStdinJson();
+    
+    const transcriptPath = data.transcript_path;
+    
+    if (!transcriptPath) {
+      console.log(JSON.stringify(HookResponse.error("No transcript path provided")));
+      process.exit(2);
+    }
+    
+    // Use spawnCLI utility for compression
+    const cliCommand = config.cliCommand || 'claude-mem';
+    
     try {
-      const data = JSON.parse(input);
-      const transcriptPath = data.transcript_path;
-      
-      if (!transcriptPath) {
-        // Output error in Claude Code expected format
-        // @docs-ref: continue: false with stopReason for blocking operations
-        console.log(JSON.stringify({
-          continue: false,
-          stopReason: "No transcript path provided"
-        }));
-        process.exit(2); // Exit 2 tells Claude Code to show error
-      }
-      
-      // Call the CLI compress command using configured name
-      const compressor = spawn(cliCommand, ['compress', transcriptPath], {
-        stdio: ['ignore', 'pipe', 'pipe'] // Capture output instead of inherit
-      });
+      await spawnCLI(cliCommand, ['compress', transcriptPath]);
       
-      let stdout = '';
-      let stderr = '';
-      
-      compressor.stdout.on('data', (data) => {
-        stdout += data.toString();
-      });
-      
-      compressor.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
-      
-      compressor.on('close', (code) => {
-        if (code !== 0) {
-          // Check if it's the Claude Code executable error
-          if (stderr.includes('Claude Code executable not found')) {
-            // This is expected when running outside Claude Code context
-            // Just output success since we can't compress without Claude SDK
-            // @docs-ref: PreCompact hooks should only use continue field, not hookSpecificOutput
-            console.log(JSON.stringify({
-              continue: true,
-              suppressOutput: true,
-              systemMessage: "Memory compression skipped - Claude SDK not available in this context"
-            }));
-            process.exit(0);
-          } else {
-            // Real error - report it
-            // @docs-ref: Use continue: false with stopReason for errors
-            console.log(JSON.stringify({
-              continue: false,
-              stopReason: `Compression failed: ${stderr}`
-            }));
-            process.exit(2);
-          }
-        } else {
-          // Success! Output confirmation
-          // @docs-ref: PreCompact hooks should only use continue field for success
-          console.log(JSON.stringify({
-            continue: true,
-            suppressOutput: true
-          }));
-          process.exit(0);
-        }
-      });
+      // Success - output response
+      console.log(JSON.stringify({
+        continue: true,
+        suppressOutput: true
+      }));
+      process.exit(0);
       
-      compressor.on('error', (error) => {
-        // @docs-ref: Use continue: false with stopReason for errors
+    } catch (error) {
+      // Check for expected Claude SDK error
+      if (error.message.includes('Claude Code executable not found')) {
         console.log(JSON.stringify({
-          continue: false,
-          stopReason: `Failed to start compression: ${error.message}`
+          continue: true,
+          suppressOutput: true,
+          systemMessage: "Memory compression skipped - Claude SDK not available in this context"
         }));
+        process.exit(0);
+      } else {
+        // Real error
+        console.log(JSON.stringify(HookResponse.error(`Compression failed: ${error.message}`)));
         process.exit(2);
-      });
-      
-    } catch (error) {
-      // @docs-ref: Use continue: false with stopReason for errors
-      console.log(JSON.stringify({
-        continue: false,
-        stopReason: `Hook error: ${error.message}`
-      }));
-      process.exit(2);
+      }
     }
-  });
+    
+  } catch (error) {
+    console.log(JSON.stringify(HookResponse.error(`Hook error: ${error.message}`)));
+    process.exit(2);
+  }
 }
 
 preCompactHook();

package/hooks/session-end.js

@@ -1,157 +1,77 @@
 #!/usr/bin/env node
 
 /**
- * 🔑 LOCKED by @docs-agent | Change to 🔑 to allow @docs-agent edits
+ * Claude Memory System - Session-End Hook (Refactored)
+ * Uses shared utilities to eliminate code duplication
  * 
- * OFFICIAL DOCS: Claude Code SessionEnd Hook v2025
- * Last Verified: 2025-08-31
- * @see https://docs.anthropic.com/en/docs/claude-code/hooks
- * 
- * Claude Memory System - Session End Hook
  * Triggers compression when session ends with reason 'clear'
- * 
- * SessionEnd Hook Payload:
- * {
- *   "session_id": "string",
- *   "transcript_path": "string",
- *   "cwd": "string",
- *   "hook_event_name": "SessionEnd",
- *   "reason": "exit" | "clear" | "error" | ...
- * }
- * 
- * Valid Response Format:
- * Success: { "continue": true }
- * Success with message: { "continue": true, "systemMessage": "string" }
- * Failure: { "continue": false, "stopReason": "error message" }
- * 
- * Note: SessionEnd hooks should generally always return continue: true
- * to avoid blocking session termination.
- * 
- * @docs-ref: SessionEnd hook should not block session ending
- * @see https://docs.anthropic.com/claude-code/hooks#sessionend
+ * Always returns continue: true to avoid blocking session termination
  */
 
-import { spawn } from 'child_process';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { readFileSync, existsSync } from 'fs';
-
-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 {
-    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
-    cliCommand = config.cliCommand || 'claude-mem';
-  } catch (e) {
-    // Fallback to default if config read fails
-  }
-}
+import { loadHookConfig, readStdinJson, HookResponse, spawnCLI } from './hook-utils.js';
 
 async function sessionEndHook() {
-  let input = '';
-  
-  // Read JSON input from stdin
-  process.stdin.on('data', chunk => {
-    input += chunk;
-  });
-  
-  process.stdin.on('end', async () => {
+  try {
+    // Load config and read input using utilities
+    const config = loadHookConfig();
+    const data = await readStdinJson();
+    
+    const { reason, transcript_path } = data;
+    
+    // Only proceed if reason is 'clear'
+    if (reason !== 'clear') {
+      console.log(JSON.stringify({ continue: true }));
+      process.exit(0);
+    }
+    
+    // Validate transcript path
+    if (!transcript_path) {
+      console.log(JSON.stringify({
+        continue: true,
+        systemMessage: "Warning: No transcript path provided for compression"
+      }));
+      process.exit(0);
+    }
+    
+    // Use spawnCLI utility for compression
+    const cliCommand = config.cliCommand || 'claude-mem';
+    
     try {
-      const data = JSON.parse(input);
-      const { reason, transcript_path, session_id } = data;
+      await spawnCLI(cliCommand, ['compress', transcript_path]);
       
-      // Only proceed if reason is 'clear'
-      if (reason !== 'clear') {
-        // For other reasons, just continue without action
-        // @docs-ref: SessionEnd hooks should not use hookSpecificOutput
-        console.log(JSON.stringify({
-          continue: true
-        }));
-        process.exit(0);
-      }
+      // Success! Memory compressed before session clear
+      console.log(JSON.stringify({
+        continue: true,
+        suppressOutput: true,
+        systemMessage: "Memory compressed successfully before session clear"
+      }));
       
-      // Validate transcript path
-      if (!transcript_path) {
-        // @docs-ref: SessionEnd should not block session ending
-        // Just continue even if we can't compress
+    } catch (error) {
+      // Check for expected Claude SDK error
+      if (error.message.includes('Claude Code executable not found')) {
         console.log(JSON.stringify({
           continue: true,
-          systemMessage: "Warning: No transcript path provided for compression"
+          suppressOutput: true
         }));
-        process.exit(0);
-      }
-      
-      // Call the CLI compress command (same as pre-compact)
-      const compressor = spawn(cliCommand, ['compress', transcript_path], {
-        stdio: ['ignore', 'pipe', 'pipe']
-      });
-      
-      let stdout = '';
-      let stderr = '';
-      
-      compressor.stdout.on('data', (data) => {
-        stdout += data.toString();
-      });
-      
-      compressor.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
-      
-      compressor.on('close', (code) => {
-        if (code !== 0) {
-          // Check if it's the Claude Code executable error
-          if (stderr.includes('Claude Code executable not found')) {
-            // This is expected when running outside Claude Code context
-            // @docs-ref: SessionEnd hooks should not use hookSpecificOutput
-            console.log(JSON.stringify({
-              continue: true,
-              suppressOutput: true
-            }));
-            process.exit(0);
-          } else {
-            // Real error - report it but allow session to end
-            // @docs-ref: Always allow session to end, use systemMessage for errors
-            console.log(JSON.stringify({
-              continue: true,
-              systemMessage: `Memory compression failed: ${stderr}`
-            }));
-            process.exit(0);
-          }
-        } else {
-          // Success! Memory compressed before session clear
-          // @docs-ref: SessionEnd hooks should not use hookSpecificOutput
-          console.log(JSON.stringify({
-            continue: true,
-            suppressOutput: true,
-            systemMessage: "Memory compressed successfully before session clear"
-          }));
-          process.exit(0);
-        }
-      });
-      
-      compressor.on('error', (error) => {
-        // Report error but allow session to end
-        // @docs-ref: Always allow session to end, use systemMessage for errors
+      } else {
+        // Real error - report it but allow session to end
         console.log(JSON.stringify({
           continue: true,
-          systemMessage: `Failed to start compression: ${error.message}`
+          systemMessage: `Memory compression failed: ${error.message}`
         }));
-        process.exit(0);
-      });
-      
-    } catch (error) {
-      // Report error but allow session to end
-      // @docs-ref: Always allow session to end, use systemMessage for errors
-      console.log(JSON.stringify({
-        continue: true,
-        systemMessage: `Hook error: ${error.message}`
-      }));
-      process.exit(0);
+      }
     }
-  });
+    
+    process.exit(0);
+    
+  } catch (error) {
+    // Report error but allow session to end
+    console.log(JSON.stringify({
+      continue: true,
+      systemMessage: `Hook error: ${error.message}`
+    }));
+    process.exit(0);
+  }
 }
 
 sessionEndHook();

package/hooks/session-start.js

@@ -1,190 +1,75 @@
 #!/usr/bin/env node
 
 /**
- * 🔒 LOCKED by @docs-agent | Change to 🔑 to allow @docs-agent edits
+ * Claude Memory System - Session-Start Hook (Refactored)
+ * Uses shared utilities to eliminate code duplication
  * 
- * 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
+ * Always loads context regardless of source (startup/compact/vscode/web)
  */
 
-import { spawn } from 'child_process';
-import { join, dirname, basename } from 'path';
-import { fileURLToPath } from 'url';
-import { readFileSync, existsSync } from 'fs';
-
-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 {
-    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
-    cliCommand = config.cliCommand || 'claude-mem';
-  } catch (e) {
-    // Fallback to default if config read fails
-  }
-}
+import { loadHookConfig, readStdinJson, HookResponse, spawnCLI } from './hook-utils.js';
+import { dirname, basename } from 'path';
 
 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
+  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);
       
-      // 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, '_');
+      // 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;
       }
       
-      // Build command to run
-      const args = ['load-context', '--format', 'session-start'];
-      
-      // Add project filter if we have a project name
+      // Sanitize project name to match what compression uses
       if (projectName) {
-        args.push('--project', projectName);
+        projectName = projectName.replace(/[^a-zA-Z0-9]/g, '_');
       }
+    }
+    
+    // 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);
       
-      // 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);
-      });
+      // 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 }));
+      }
       
     } catch (error) {
-      // Any errors, just continue without additional context
-      // @docs-ref: Always return valid response format
-      console.log(JSON.stringify({
-        continue: true
-      }));
-      process.exit(0);
+      // If load-context fails, just continue without context
+      // This could happen if no index exists yet
+      console.log(JSON.stringify({ continue: true }));
     }
-  });
+    
+    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.0.9",
+  "version": "2.1.1",
   "description": "Memory compression system for Claude Code - persist context across sessions",
   "keywords": [
     "claude",

package/src/claude-mem.js

@@ -6,6 +6,7 @@ import path, { join } from 'path';
 import os, { homedir } from 'os';
 import { fileURLToPath } from 'url';
 import { createAnalysisPrompt, DEBUG_MESSAGES } from '../dist/constants.js';
+import { log } from '../dist/utils/logger.js';
 
 const DEBUG_MODE = true;
 const CLAUDE_MEM_HOME = path.join(homedir(), '.claude-mem');
@@ -438,9 +439,10 @@ class TranscriptCompressor {
 
       return archivePath;
     } catch (error) {
-      console.error(`\n❌ COMPRESSION FAILED`);
-      console.error(`  Error: ${error.message}`);
-      console.error(`  Stack: ${error.stack}`);
+      log.error('COMPRESSION FAILED', error, {
+        errorMessage: error.message,
+        stack: error.stack
+      });
       throw error;
     }
   }
@@ -823,9 +825,7 @@ async function main() {
   const args = process.argv.slice(2);
 
   if (args.length === 0) {
-    console.error(
-      'Usage: node src/claude-mem.js <transcript-path> [session-id]'
-    );
+    log.error('Usage: node src/claude-mem.js <transcript-path> [session-id]');
     closeDebugLog();
     process.exit(1);
   }
@@ -847,7 +847,7 @@ async function main() {
     debugLog(`❌ Compression failed: ${error.message}`);
     debugLog(`💥 Stack trace: ${error.stack}`);
     closeDebugLog();
-    console.error('❌ Compression failed:', error.message);
+    log.error('Compression failed', error);
     process.exit(1);
   }
 }