claude-mem 2.0.10 → 2.1.2

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();