@alex900530/claude-persistent-memory 1.0.0

package/hooks/post-tool-memory-hook.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse Memory Hook - Result-triggered memory Push
+ *
+ * How it works:
+ *   1. Reads {tool_name, tool_input, tool_response} from stdin
+ *   2. Concatenates all context into a query (tool name, file paths, commands, content, output, etc.)
+ *   3. Performs vector search via embedding service (TCP)
+ *   4. Injects found memories via JSON stdout additionalContext into Claude context
+ *
+ * Performance budget: < 300ms
+ */
+
+const net = require('net');
+const fs = require('fs');
+const path = require('path');
+
+const config = require('../config');
+
+const EMBEDDING_PORT = config.embeddingPort;
+const TIMEOUT_MS = config.timeout.hookPostTool;
+const MAX_RESULTS = config.search.maxResults;
+const MIN_SIMILARITY = config.search.minSimilarity;
+const LOG_FILE = path.join(config.logDir, 'hook-inject.log');
+
+function output(additionalContext) {
+  const result = {};
+  if (additionalContext) {
+    result.hookSpecificOutput = {
+      hookEventName: 'PostToolUse',
+      additionalContext,
+    };
+  }
+  console.log(JSON.stringify(result));
+}
+
+/**
+ * Concatenate tool_input + tool_response fields into a single query string
+ */
+function buildQuery(tool, toolInput, toolResponse) {
+  const parts = [tool];
+  if (toolInput.file_path) parts.push(toolInput.file_path);
+  if (toolInput.command) parts.push(toolInput.command);
+  if (toolInput.description) parts.push(toolInput.description);
+  if (toolInput.old_string) parts.push(toolInput.old_string);
+  if (toolInput.new_string) parts.push(toolInput.new_string);
+  if (toolInput.content) parts.push(toolInput.content);
+  if (toolInput.pattern) parts.push(toolInput.pattern);
+  if (toolInput.path) parts.push(toolInput.path);
+  if (toolResponse) {
+    const responseStr = typeof toolResponse === 'string' ? toolResponse : JSON.stringify(toolResponse);
+    parts.push(responseStr.slice(0, 500));
+  }
+  return parts.join(' ');
+}
+
+function searchViaEmbedding(query, limit) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    let buffer = '';
+    let resolved = false;
+
+    const timer = setTimeout(() => {
+      if (!resolved) { resolved = true; socket.destroy(); resolve(null); }
+    }, TIMEOUT_MS - 50);
+
+    socket.connect(EMBEDDING_PORT, '127.0.0.1', () => {
+      socket.write(JSON.stringify({ action: 'search', query, limit }) + '\n');
+    });
+
+    socket.on('data', (data) => {
+      buffer += data.toString();
+      if (buffer.includes('\n') && !resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        socket.destroy();
+        try {
+          const response = JSON.parse(buffer.split('\n')[0]);
+          resolve(response.success ? response.results : null);
+        } catch { resolve(null); }
+      }
+    });
+
+    socket.on('error', () => {
+      if (!resolved) { resolved = true; clearTimeout(timer); resolve(null); }
+    });
+  });
+}
+
+function formatReminder(memories) {
+  const lines = ['<memory_context source="post-tool">'];
+  for (const m of memories) {
+    const content = m.content || m.rawContent || '';
+    const sim = m.vectorSimilarity ? m.vectorSimilarity.toFixed(2) : '?';
+    lines.push(`[#${m.id} ${m.type || '?'}/${m.domain || '?'} sim=${sim}]`);
+    lines.push(content);
+    lines.push('');
+  }
+  lines.push('</memory_context>');
+  return lines.join('\n');
+}
+
+async function main() {
+  let input = '';
+  for await (const chunk of process.stdin) { input += chunk; }
+
+  const failsafe = setTimeout(() => {
+    output();
+    process.exit(0);
+  }, TIMEOUT_MS);
+
+  try {
+    const data = JSON.parse(input.trim());
+    const tool = data.tool_name;
+    const toolInput = data.tool_input || {};
+    const toolResponse = data.tool_response || '';
+
+    if (!['Bash', 'Edit', 'Write'].includes(tool)) {
+      clearTimeout(failsafe);
+      output();
+      return;
+    }
+
+    const query = buildQuery(tool, toolInput, toolResponse);
+    if (!query || query.length < 5) {
+      clearTimeout(failsafe);
+      output();
+      return;
+    }
+
+    const raw = await searchViaEmbedding(query, MAX_RESULTS);
+    clearTimeout(failsafe);
+    const results = raw ? raw.filter(m => (m.vectorSimilarity || 0) >= MIN_SIMILARITY) : [];
+
+    if (results.length > 0) {
+      const ids = results.map(m => `#${m.id}(${(m.vectorSimilarity||0).toFixed(2)})`).join(' ');
+      try { fs.appendFileSync(LOG_FILE, `${new Date().toISOString()} [post-tool] injected: ${ids}\n`); } catch {}
+      output(formatReminder(results));
+    } else {
+      output();
+    }
+  } catch {
+    clearTimeout(failsafe);
+    output();
+  }
+}
+
+main().catch(() => {
+  output();
+  process.exit(0);
+});

package/hooks/pre-compact-hook.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+/**
+ * PreCompact Hook - Async session analysis
+ *
+ * Simplified: immediately outputs stdin (does not block compact),
+ * then spawns compact-analyzer in the background for LLM analysis.
+ * All analysis logic is in compact-analyzer.js, handled by LLM in full.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const config = require('../config');
+
+const LOG_FILE = path.join(config.logDir, 'compact-analyzer.log');
+
+function log(msg) {
+  const line = `[${new Date().toISOString()}] ${msg}\n`;
+  try { fs.appendFileSync(LOG_FILE, line); } catch (e) {}
+}
+
+async function main() {
+  let input = '';
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+
+  // Output immediately, do not block compact
+  console.log(input);
+
+  try {
+    const data = JSON.parse(input.trim());
+    const transcriptPath = data.transcript_path;
+    const sessionId = data.session_id || 'unknown';
+    const cwd = data.cwd || process.cwd();
+
+    if (!transcriptPath) return;
+
+    // Spawn analyzer in background
+    const analyzerPath = path.join(__dirname, '..', 'lib', 'compact-analyzer.js');
+    const child = spawn('node', [analyzerPath, transcriptPath, sessionId, cwd], {
+      detached: true,
+      stdio: 'ignore',
+      env: process.env
+    });
+    child.unref();
+
+    log(`[PreCompact] Spawned analyzer (PID ${child.pid}) for session ${sessionId}`);
+  } catch (e) {
+    log(`[PreCompact] Error: ${e.message}`);
+  }
+}
+
+// Preserve loadMessagesFromTranscript export (backward compatibility)
+const { loadMessagesFromTranscript } = require('../lib/compact-analyzer');
+module.exports = { loadMessagesFromTranscript };
+
+if (require.main === module) {
+  main().catch(() => {});
+}

package/hooks/pre-tool-memory-hook.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+/**
+ * PreToolUse Memory Hook - Action-triggered memory Push
+ *
+ * How it works:
+ *   1. Reads {tool_name, tool_input} from stdin
+ *   2. Concatenates all context into a query (tool name, file paths, commands, content, etc.)
+ *   3. Performs vector search via embedding service (TCP)
+ *   4. Injects found memories via JSON stdout additionalContext into Claude context
+ *
+ * Performance budget: < 300ms
+ */
+
+const net = require('net');
+const fs = require('fs');
+const path = require('path');
+
+const config = require('../config');
+
+const EMBEDDING_PORT = config.embeddingPort;
+const TIMEOUT_MS = config.timeout.hookPreTool;
+const MAX_RESULTS = config.search.maxResults;
+const MIN_SIMILARITY = config.search.minSimilarity;
+const LOG_FILE = path.join(config.logDir, 'hook-inject.log');
+
+function output(additionalContext) {
+  const result = {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'allow',
+    }
+  };
+  if (additionalContext) {
+    result.hookSpecificOutput.additionalContext = additionalContext;
+  }
+  console.log(JSON.stringify(result));
+}
+
+/**
+ * Concatenate all tool_input fields into a single query string
+ */
+function buildQuery(tool, toolInput) {
+  const parts = [tool];
+  if (toolInput.file_path) parts.push(toolInput.file_path);
+  if (toolInput.command) parts.push(toolInput.command);
+  if (toolInput.description) parts.push(toolInput.description);
+  if (toolInput.old_string) parts.push(toolInput.old_string);
+  if (toolInput.new_string) parts.push(toolInput.new_string);
+  if (toolInput.content) parts.push(toolInput.content);
+  if (toolInput.pattern) parts.push(toolInput.pattern);
+  if (toolInput.path) parts.push(toolInput.path);
+  return parts.join(' ');
+}
+
+function searchViaEmbedding(query, limit) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    let buffer = '';
+    let resolved = false;
+
+    const timer = setTimeout(() => {
+      if (!resolved) { resolved = true; socket.destroy(); resolve(null); }
+    }, TIMEOUT_MS - 50);
+
+    socket.connect(EMBEDDING_PORT, '127.0.0.1', () => {
+      socket.write(JSON.stringify({ action: 'search', query, limit }) + '\n');
+    });
+
+    socket.on('data', (data) => {
+      buffer += data.toString();
+      if (buffer.includes('\n') && !resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        socket.destroy();
+        try {
+          const response = JSON.parse(buffer.split('\n')[0]);
+          resolve(response.success ? response.results : null);
+        } catch { resolve(null); }
+      }
+    });
+
+    socket.on('error', () => {
+      if (!resolved) { resolved = true; clearTimeout(timer); resolve(null); }
+    });
+  });
+}
+
+function formatReminder(memories) {
+  const lines = ['<memory_context source="pre-tool">'];
+  for (const m of memories) {
+    const content = m.content || m.rawContent || '';
+    const sim = m.vectorSimilarity ? m.vectorSimilarity.toFixed(2) : '?';
+    lines.push(`[#${m.id} ${m.type || '?'}/${m.domain || '?'} sim=${sim}]`);
+    lines.push(content);
+    lines.push('');
+  }
+  lines.push('</memory_context>');
+  return lines.join('\n');
+}
+
+async function main() {
+  let input = '';
+  for await (const chunk of process.stdin) { input += chunk; }
+
+  const failsafe = setTimeout(() => {
+    output();
+    process.exit(0);
+  }, TIMEOUT_MS);
+
+  try {
+    const data = JSON.parse(input.trim());
+    const tool = data.tool_name;
+    const toolInput = data.tool_input || {};
+
+    if (!['Edit', 'Write', 'Bash'].includes(tool)) {
+      clearTimeout(failsafe);
+      output();
+      return;
+    }
+
+    const query = buildQuery(tool, toolInput);
+    if (!query || query.length < 5) {
+      clearTimeout(failsafe);
+      output();
+      return;
+    }
+
+    const raw = await searchViaEmbedding(query, MAX_RESULTS);
+    clearTimeout(failsafe);
+    const results = raw ? raw.filter(m => (m.vectorSimilarity || 0) >= MIN_SIMILARITY) : [];
+
+    if (results.length > 0) {
+      const ids = results.map(m => `#${m.id}(${(m.vectorSimilarity||0).toFixed(2)})`).join(' ');
+      try { fs.appendFileSync(LOG_FILE, `${new Date().toISOString()} [pre-tool] injected: ${ids}\n`); } catch {}
+      output(formatReminder(results));
+    } else {
+      output();
+    }
+  } catch {
+    clearTimeout(failsafe);
+    output();
+  }
+}
+
+main().catch(() => {
+  output();
+  process.exit(0);
+});

package/hooks/session-end-hook.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+/**
+ * SessionEnd Hook - Incremental transcript analysis + clustering + mature cluster merging
+ *
+ * Features:
+ * - Incremental transcript analysis: extract error patterns, code changes, user preferences
+ * - Process unclustered memories, attempt to create new clusters
+ * - Mature cluster memories automatically merged into a single high-confidence memory
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const config = require('../config');
+const { log } = require('../lib/utils');
+
+const DATA_DIR = config.dataDir;
+
+// Clustering configuration
+const MIN_CLUSTER_CONFIDENCE = 0.6;
+
+let memoryDb = null;
+
+function getMemoryDb() {
+  if (memoryDb) return memoryDb;
+  try {
+    memoryDb = require('../lib/memory-db');
+    return memoryDb;
+  } catch (e) {
+    log(`[SessionEnd] Warning: memory-db not available: ${e.message}`);
+    return null;
+  }
+}
+
+/**
+ * Incremental transcript analysis: from last compact position to session end
+ */
+async function analyzeTranscriptIncremental(sessionId, transcriptPath) {
+  const db = getMemoryDb();
+  if (!db || !transcriptPath || !sessionId) return;
+
+  try {
+    const { analyzeAndSave } = require('../lib/compact-analyzer');
+
+    const result = await analyzeAndSave(transcriptPath, sessionId, { memoryDb: db });
+    log(`[SessionEnd] Transcript analysis: saved ${result.saved || 0} memories`);
+
+    // Clean up state file (session ended, no longer needed)
+    const stateFile = path.join(DATA_DIR, `compact-state-${sessionId}.json`);
+    try {
+      if (fs.existsSync(stateFile)) {
+        fs.unlinkSync(stateFile);
+        log(`[SessionEnd] Cleaned up state file`);
+      }
+    } catch (e) {}
+  } catch (e) {
+    log(`[SessionEnd] Error in analyzeTranscriptIncremental: ${e.message}`);
+  }
+}
+
+/**
+ * Process unclustered memories, attempt to create new clusters
+ */
+async function processUnclusteredMemories() {
+  const db = getMemoryDb();
+  if (!db) return;
+
+  try {
+    log('[SessionEnd] Processing unclustered memories...');
+
+    const result = await db.autoCluster({
+      minConfidence: MIN_CLUSTER_CONFIDENCE,
+      hoursBack: 24
+    });
+
+    if (result.length === 0) {
+      log('[SessionEnd] No new clusters created');
+      return;
+    }
+
+    for (const c of result) {
+      log(`[SessionEnd] Created new cluster: ${c.theme} (${c.memberCount} members, ${c.status})`);
+    }
+  } catch (e) {
+    log(`[SessionEnd] Error in processUnclusteredMemories: ${e.message}`);
+  }
+}
+
+/**
+ * Mature cluster memory merging: multiple memories merged into one high-confidence memory
+ */
+async function mergeMatureClusters() {
+  const db = getMemoryDb();
+  if (!db) return;
+
+  try {
+    const matureClusters = db.getMatureClusters();
+    if (matureClusters.length === 0) {
+      log('[SessionEnd] No mature clusters to merge');
+      return;
+    }
+
+    for (const cluster of matureClusters) {
+      const result = await db.mergeClusterMemories(cluster.id);
+      if (result) {
+        log(`[SessionEnd] Merged cluster #${cluster.id}: "${result.summary}" (${result.memberCount} memories -> ID ${result.memoryId})`);
+      }
+    }
+  } catch (e) {
+    log(`[SessionEnd] Error in mergeMatureClusters: ${e.message}`);
+  }
+}
+
+async function main() {
+  log('[SessionEnd] Processing session end...');
+
+  // Read stdin for session data
+  let sessionData = {};
+  try {
+    let input = '';
+    for await (const chunk of process.stdin) {
+      input += chunk;
+    }
+    if (input.trim()) {
+      sessionData = JSON.parse(input);
+    }
+  } catch (e) {
+    log(`[SessionEnd] Failed to parse stdin: ${e.message}`);
+  }
+
+  const sessionId = sessionData.session_id;
+  const transcriptPath = sessionData.transcript_path;
+
+  log(`[SessionEnd] Session: ${sessionId || 'unknown'}, transcript: ${transcriptPath || 'none'}`);
+
+  // 1. Incremental transcript analysis (from last compact position to session end)
+  if (sessionId && transcriptPath) {
+    await analyzeTranscriptIncremental(sessionId, transcriptPath);
+  }
+
+  // 2. Process unclustered memories, attempt to create new clusters
+  await processUnclusteredMemories();
+
+  // 3. Mature cluster memory merging
+  await mergeMatureClusters();
+
+  // Close database
+  if (memoryDb) {
+    memoryDb.closeDb();
+  }
+
+  log('[SessionEnd] Session end processing complete');
+  process.exit(0);
+}
+
+main().catch(err => {
+  console.error('[SessionEnd] Error:', err.message);
+  process.exit(0);
+});

package/hooks/user-prompt-hook.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+/**
+ * User Prompt Hook - Memory retrieval on user prompt
+ *
+ * Stripped-down version: only performs memory search via embedding service.
+ * No compact suggestion logic (that is an optional add-on, not part of core memory).
+ *
+ * How it works:
+ *   1. Reads raw user prompt from stdin
+ *   2. Extracts the actual prompt text
+ *   3. Searches memories via embedding service (TCP)
+ *   4. Outputs memory context + original prompt via stdout
+ */
+
+const net = require('net');
+const fs = require('fs');
+const path = require('path');
+
+const config = require('../config');
+
+const EMBEDDING_PORT = config.embeddingPort;
+const TIMEOUT_MS = config.timeout.hookUserPrompt;
+const SEARCH_TIMEOUT_MS = config.timeout.embeddingSearch;
+const MAX_RESULTS = config.search.maxResults;
+const MIN_SIMILARITY = config.search.minSimilarity;
+const LOG_FILE = path.join(config.logDir, 'hook-inject.log');
+
+/**
+ * Extract the actual user prompt from raw stdin input.
+ * The input may be wrapped in JSON with a "prompt" field.
+ */
+function extractUserPrompt(rawInput) {
+  try {
+    const jsonMatch = rawInput.match(/\{[\s\S]*"prompt"\s*:\s*"[\s\S]*"\s*[\s\S]*\}$/);
+    if (jsonMatch) {
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (parsed.prompt) return parsed.prompt;
+    }
+  } catch (e) {}
+  return rawInput;
+}
+
+// --- Embedding memory search ---
+
+function searchViaEmbedding(query, limit) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    let buffer = '';
+    let resolved = false;
+
+    const timer = setTimeout(() => {
+      if (!resolved) { resolved = true; socket.destroy(); resolve(null); }
+    }, SEARCH_TIMEOUT_MS);
+
+    socket.connect(EMBEDDING_PORT, '127.0.0.1', () => {
+      socket.write(JSON.stringify({ action: 'search', query, limit }) + '\n');
+    });
+
+    socket.on('data', (data) => {
+      buffer += data.toString();
+      if (buffer.includes('\n') && !resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        socket.destroy();
+        try {
+          const response = JSON.parse(buffer.split('\n')[0]);
+          resolve(response.success ? response.results : null);
+        } catch { resolve(null); }
+      }
+    });
+
+    socket.on('error', () => {
+      if (!resolved) { resolved = true; clearTimeout(timer); resolve(null); }
+    });
+  });
+}
+
+function formatReminder(memories) {
+  const lines = ['<memory_context source="user-prompt">'];
+  for (const m of memories) {
+    const content = m.content || m.rawContent || '';
+    const sim = m.vectorSimilarity ? m.vectorSimilarity.toFixed(2) : '?';
+    lines.push(`[#${m.id} ${m.type || '?'}/${m.domain || '?'} sim=${sim}]`);
+    lines.push(content);
+    lines.push('');
+  }
+  lines.push('</memory_context>');
+  return lines.join('\n');
+}
+
+// --- Main ---
+
+async function main() {
+  let userMessage = '';
+  for await (const chunk of process.stdin) {
+    userMessage += chunk;
+  }
+  userMessage = userMessage.trim();
+
+  let resolved = false;
+  const timer = setTimeout(() => {
+    if (!resolved) {
+      resolved = true;
+      console.log(userMessage);
+      process.exit(0);
+    }
+  }, TIMEOUT_MS);
+
+  try {
+    if (!userMessage || userMessage.length < 10) {
+      clearTimeout(timer);
+      if (!resolved) { resolved = true; console.log(userMessage); }
+      return;
+    }
+
+    const actualPrompt = extractUserPrompt(userMessage);
+
+    // Embedding memory search: use the full user prompt as query
+    const query = actualPrompt;
+    let memoryContext = '';
+    if (query.length >= 5) {
+      const raw = await searchViaEmbedding(query, MAX_RESULTS);
+      const results = raw ? raw.filter(m => (m.vectorSimilarity || 0) >= MIN_SIMILARITY) : [];
+      if (results.length > 0) {
+        const ids = results.map(m => `#${m.id}(${(m.vectorSimilarity||0).toFixed(2)})`).join(' ');
+        try { fs.appendFileSync(LOG_FILE, `${new Date().toISOString()} [user-prompt] injected: ${ids}\n`); } catch {}
+        memoryContext = formatReminder(results);
+      }
+    }
+
+    clearTimeout(timer);
+    if (resolved) return;
+    resolved = true;
+
+    let output = '';
+    if (memoryContext) {
+      output += memoryContext + '\n\n';
+    }
+
+    console.log(output + userMessage);
+  } catch (e) {
+    clearTimeout(timer);
+    if (!resolved) { resolved = true; console.log(userMessage); }
+  }
+}
+
+main().catch(() => {
+  let data = '';
+  process.stdin.on('data', chunk => data += chunk);
+  process.stdin.on('end', () => console.log(data));
+});