universal-memory-mcp 0.2.3 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "universal-memory-mcp",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "MCP Server for persistent AI memory across sessions",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,7 +25,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "universal-memory-core": "^0.1.3"
+    "universal-memory-core": "^0.1.4"
   },
   "devDependencies": {
     "@types/node": "^20.11.0",

package/scripts/postinstall.js

@@ -12,8 +12,10 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 
-const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), '.claude', 'settings.json');
-const CLAUDE_SKILLS_PATH = path.join(os.homedir(), '.claude', 'skills');
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+const CLAUDE_SETTINGS_PATH = path.join(CLAUDE_DIR, 'settings.json');
+const CLAUDE_SKILLS_PATH = path.join(CLAUDE_DIR, 'skills');
+const CLAUDE_HOOKS_PATH = path.join(CLAUDE_DIR, 'hooks');
 
 // MCP server configuration
 const MCP_CONFIG = {
@@ -155,6 +157,21 @@ memory_update_long_term({
 - Use project name when in project context
 `;
 
+/**
+ * Check if Claude Code is installed
+ */
+function checkClaudeCodeInstalled() {
+  if (!fs.existsSync(CLAUDE_DIR)) {
+    console.log('\n⚠️  Claude Code not detected!\n');
+    console.log('Please install Claude Code first:');
+    console.log('  https://code.claude.com/\n');
+    console.log('After installing Claude Code, run:');
+    console.log('  npm install -g universal-memory-mcp\n');
+    return false;
+  }
+  return true;
+}
+
 /**
  * Read JSON file safely
  */
@@ -253,6 +270,92 @@ function installSkill() {
   return true;
 }
 
+/**
+ * Install Stop hook script
+ */
+function installStopHook() {
+  console.log('\n🪝 Installing Stop hook...');
+
+  const hookScriptPath = path.join(CLAUDE_HOOKS_PATH, 'universal-memory-stop-hook.mjs');
+
+  // Create hooks directory if not exists
+  if (!fs.existsSync(CLAUDE_HOOKS_PATH)) {
+    fs.mkdirSync(CLAUDE_HOOKS_PATH, { recursive: true });
+    console.log('  Created hooks directory');
+  }
+
+  // Get source script path (in the same directory as this postinstall script)
+  const sourceScript = new URL('universal-memory-stop-hook.mjs', import.meta.url).pathname;
+
+  // Check if hook already exists
+  if (fs.existsSync(hookScriptPath)) {
+    const existingContent = fs.readFileSync(hookScriptPath, 'utf-8');
+    const newContent = fs.readFileSync(sourceScript, 'utf-8');
+
+    if (existingContent === newContent) {
+      console.log('  Stop hook already installed (same version)');
+      return false;
+    }
+
+    // Backup existing hook
+    const backupPath = `${hookScriptPath}.backup.${Date.now()}`;
+    fs.copyFileSync(hookScriptPath, backupPath);
+    console.log(`  Backed up existing hook to: ${backupPath}`);
+  }
+
+  fs.copyFileSync(sourceScript, hookScriptPath);
+  fs.chmodSync(hookScriptPath, 0o755); // Make executable
+  console.log('  Stop hook installed successfully');
+  return true;
+}
+
+/**
+ * Configure Stop hook in Claude settings
+ */
+function configureStopHook() {
+  console.log('\n⚙️  Configuring Stop hook...');
+
+  let settings = readJsonFile(CLAUDE_SETTINGS_PATH) || {};
+
+  // Initialize hooks if not exists
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+
+  // Initialize Stop hook array if not exists
+  if (!settings.hooks.Stop) {
+    settings.hooks.Stop = [];
+  }
+
+  // Check if our hook is already configured
+  const hookScriptPath = path.join(os.homedir(), '.claude', 'hooks', 'universal-memory-stop-hook.mjs');
+  const hookCommand = `node ${hookScriptPath}`;
+  const alreadyConfigured = settings.hooks.Stop.some(entry =>
+    entry.hooks?.some(hook =>
+      hook.type === 'command' && hook.command.includes('universal-memory-stop-hook')
+    )
+  );
+
+  if (alreadyConfigured) {
+    console.log('  Stop hook already configured');
+    return false;
+  }
+
+  // Add Stop hook configuration
+  settings.hooks.Stop.push({
+    hooks: [
+      {
+        type: 'command',
+        command: hookCommand
+      }
+    ]
+  });
+
+  writeJsonFile(CLAUDE_SETTINGS_PATH, settings);
+  console.log('  Stop hook configured successfully');
+  return true;
+}
+
 /**
  * Main installation
  */
@@ -261,26 +364,39 @@ function main() {
   console.log('║         Universal Memory MCP - Setup                       ║');
   console.log('╚════════════════════════════════════════════════════════════╝');
 
+  // Check Claude Code installation
+  if (!checkClaudeCodeInstalled()) {
+    process.exit(0);
+  }
+
   let needsRestart = false;
 
   try {
-    // Configure MCP server
+    // 1. Configure MCP server
     const mcpConfigured = configureMcpServer();
     if (mcpConfigured) needsRestart = true;
 
-    // Install skill
+    // 2. Install skill
     const skillInstalled = installSkill();
     if (skillInstalled) needsRestart = true;
 
+    // 3. Install Stop hook script
+    const hookInstalled = installStopHook();
+    if (hookInstalled) needsRestart = true;
+
+    // 4. Configure Stop hook
+    const hookConfigured = configureStopHook();
+    if (hookConfigured) needsRestart = true;
+
     // Summary
     console.log('\n' + '═'.repeat(60));
 
     if (needsRestart) {
       console.log('\n✅ Setup complete!\n');
-      console.log('⚠️  IMPORTANT: Please restart Claude Code to enable the MCP server.\n');
+      console.log('⚠️  IMPORTANT: Please restart Claude Code to enable all features.\n');
       console.log('After restart, Claude will automatically:');
       console.log('  • Search past conversations when you reference them');
-      console.log('  • Record important conversations for future recall');
+      console.log('  • Record EVERY conversation automatically (via Stop hook)');
       console.log('  • Remember your preferences and decisions\n');
     } else {
       console.log('\n✅ Already configured! No changes needed.\n');
@@ -289,6 +405,7 @@ function main() {
     console.log('📁 Configuration locations:');
     console.log(`   MCP config: ${CLAUDE_SETTINGS_PATH}`);
     console.log(`   Skill: ${path.join(CLAUDE_SKILLS_PATH, 'memory-assistant', 'SKILL.md')}`);
+    console.log(`   Stop hook: ${path.join(CLAUDE_HOOKS_PATH, 'universal-memory-stop-hook.mjs')}`);
     console.log(`   Memory storage: ${path.join(os.homedir(), '.ai_memory')}\n`);
 
   } catch (error) {

package/scripts/universal-memory-stop-hook.mjs

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+// Enable debug logging via environment variable
+const DEBUG = process.env.UNIVERSAL_MEMORY_DEBUG === '1';
+
+function debugLog(message) {
+  if (DEBUG) {
+    fs.appendFileSync('/tmp/universal-memory-stop-hook.log', `[${new Date().toISOString()}] ${message}\n`);
+  }
+}
+
+function readStdinSync() {
+  return fs.readFileSync(0, 'utf8');
+}
+
+function isNonEmptyString(value) {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+function contentToText(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((item) => {
+        if (typeof item === 'string') return item;
+        if (item && typeof item === 'object' && typeof item.text === 'string') return item.text;
+        if (item && typeof item === 'object' && typeof item.content === 'string') return item.content;
+        return '';
+      })
+      .filter(Boolean)
+      .join('\n');
+  }
+  if (content && typeof content === 'object') {
+    if (typeof content.text === 'string') return content.text;
+    if (typeof content.content === 'string') return content.content;
+  }
+  return '';
+}
+
+function extractMessages(transcriptJson) {
+  if (!transcriptJson || typeof transcriptJson !== 'object') return [];
+
+  if (Array.isArray(transcriptJson.messages)) return transcriptJson.messages;
+  if (Array.isArray(transcriptJson.turns)) return transcriptJson.turns;
+  if (Array.isArray(transcriptJson.events)) return transcriptJson.events;
+  if (Array.isArray(transcriptJson.transcript)) return transcriptJson.transcript;
+
+  if (transcriptJson.conversation && Array.isArray(transcriptJson.conversation.messages)) {
+    return transcriptJson.conversation.messages;
+  }
+
+  return [];
+}
+
+function extractLastExchange(messages) {
+  const normalized = messages
+    .map((m) => {
+      if (!m || typeof m !== 'object') return null;
+      const role = m.role || m.author || m.type;
+      const content = m.content ?? m.text ?? m.message ?? m.data?.content;
+      return {
+        role: typeof role === 'string' ? role : '',
+        text: contentToText(content),
+      };
+    })
+    .filter(Boolean)
+    .filter((m) => isNonEmptyString(m.role) && isNonEmptyString(m.text));
+
+  const roleNorm = (r) => String(r).toLowerCase();
+  const lastUserIdx = (() => {
+    for (let i = normalized.length - 1; i >= 0; i--) {
+      if (roleNorm(normalized[i].role) === 'user') return i;
+    }
+    return -1;
+  })();
+
+  const lastAssistantIdxAfterUser = (() => {
+    if (lastUserIdx === -1) return -1;
+    for (let i = lastUserIdx + 1; i < normalized.length; i++) {
+      if (roleNorm(normalized[i].role) === 'assistant') return i;
+    }
+    return -1;
+  })();
+
+  const lastAssistantIdx = (() => {
+    for (let i = normalized.length - 1; i >= 0; i--) {
+      if (roleNorm(normalized[i].role) === 'assistant') return i;
+    }
+    return -1;
+  })();
+
+  const userText = lastUserIdx !== -1 ? normalized[lastUserIdx].text : '';
+  const aiText =
+    lastAssistantIdxAfterUser !== -1
+      ? normalized[lastAssistantIdxAfterUser].text
+      : lastAssistantIdx !== -1
+        ? normalized[lastAssistantIdx].text
+        : '';
+
+  return { userText, aiText };
+}
+
+function truncate(text, maxChars) {
+  if (!isNonEmptyString(text)) return '';
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars) + `\n\n[truncated to ${maxChars} chars]`;
+}
+
+function findUp(startDir, relativeTarget) {
+  let dir = startDir;
+  for (;;) {
+    const candidate = path.join(dir, relativeTarget);
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+function runRecordCommand(payload, cwd) {
+  const input = JSON.stringify(payload);
+
+  const direct = spawnSync('universal-memory-record', ['--json'], {
+    input,
+    encoding: 'utf8',
+    cwd,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  if (direct.status === 0) return { ok: true, id: direct.stdout.trim() };
+
+  const npx = spawnSync(
+    'npx',
+    ['-y', '--package', 'universal-memory-mcp', 'universal-memory-record', '--json'],
+    {
+      input,
+      encoding: 'utf8',
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }
+  );
+  if (npx.status === 0) return { ok: true, id: npx.stdout.trim() };
+
+  const distPath = findUp(cwd, path.join('packages', 'mcp-server', 'dist', 'record.js'));
+  if (!distPath) {
+    return {
+      ok: false,
+      error: 'universal-memory-record not found (PATH/npx) and dist/record.js not found',
+    };
+  }
+
+  const fallback = spawnSync('node', [distPath, '--json'], {
+    input,
+    encoding: 'utf8',
+    cwd,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  if (fallback.status === 0) return { ok: true, id: fallback.stdout.trim() };
+  return { ok: false, error: fallback.stderr || fallback.stdout || 'record command failed' };
+}
+
+function detectProjectName(cwd) {
+  try {
+    const gitDir = findUp(cwd, '.git');
+    if (gitDir) return path.basename(path.dirname(gitDir));
+  } catch {
+    return undefined;
+  }
+  return undefined;
+}
+
+function main() {
+  debugLog('Stop hook triggered');
+
+  const raw = readStdinSync();
+  if (!raw.trim()) {
+    debugLog('No stdin input, exiting');
+    process.exit(0);
+  }
+
+  debugLog(`Received input: ${raw.substring(0, 200)}...`);
+
+  let hookInput;
+  try {
+    hookInput = JSON.parse(raw);
+  } catch (err) {
+    debugLog(`Failed to parse input JSON: ${err.message}`);
+    process.exit(0);
+  }
+
+  const cwd = hookInput.cwd || process.cwd();
+  const transcriptPath = hookInput.transcript_path || hookInput.transcriptPath;
+  const sessionId = hookInput.session_id || hookInput.sessionId;
+
+  debugLog(`transcript_path: ${transcriptPath}`);
+
+  if (!isNonEmptyString(transcriptPath)) {
+    debugLog('No transcript_path, exiting');
+    process.exit(0);
+  }
+
+  let messages;
+  try {
+    const transcriptContent = fs.readFileSync(transcriptPath, 'utf8');
+
+    // Parse JSONL format (one JSON object per line)
+    const lines = transcriptContent.trim().split('\n').filter(line => line.trim());
+    const entries = lines.map(line => JSON.parse(line));
+
+    debugLog(`Successfully read ${entries.length} transcript entries`);
+
+    // Extract messages from JSONL entries
+    messages = entries
+      .filter(entry => entry.type === 'user' || entry.type === 'assistant')
+      .map(entry => ({
+        role: entry.type === 'user' ? 'user' : 'assistant',
+        content: entry.message?.content || entry.content
+      }));
+
+    debugLog(`Extracted ${messages.length} messages from JSONL`);
+  } catch (err) {
+    debugLog(`Failed to read transcript: ${err.message}`);
+    process.exit(0);
+  }
+
+  const { userText, aiText } = extractLastExchange(messages);
+  debugLog(`userText length: ${userText.length}, aiText length: ${aiText.length}`);
+
+  if (!isNonEmptyString(userText) || !isNonEmptyString(aiText)) {
+    debugLog('Empty user or AI text, exiting');
+    process.exit(0);
+  }
+
+  // Determine client - default to 'claude-code' if not provided
+  const client = isNonEmptyString(hookInput.client) ? hookInput.client : 'claude-code';
+
+  const payload = {
+    user_message: truncate(userText, 8000),
+    ai_response: truncate(aiText, 20000),
+    project: detectProjectName(cwd),
+    client: client,
+    session_id: isNonEmptyString(sessionId) ? sessionId : undefined,
+    working_directory: cwd,
+  };
+
+  debugLog(`Payload: client=${client}, project=${payload.project}, session_id=${payload.session_id}`);
+
+  const res = runRecordCommand(payload, cwd);
+  if (!res.ok) {
+    const errorMsg = `universal-memory stop hook warning: ${res.error}\n`;
+    process.stderr.write(errorMsg);
+    debugLog(`Error: ${res.error}`);
+  } else {
+    debugLog(`Successfully saved memory: ${res.id}`);
+  }
+}
+
+main();