@alex900530/claude-persistent-memory 1.0.7 → 1.1.0

package/bin/setup.js

@@ -161,9 +161,9 @@ function setupHooks() {
   ok('  Hooks configured (5 hooks).');
 }
 
-// ── [4/5] .gitignore ────────────────────────────────────────────────────────
+// ── [4/6] .gitignore ────────────────────────────────────────────────────────
 function setupGitignore() {
-  log('[4/5] Updating .gitignore ...');
+  log('[4/6] Updating .gitignore ...');
 
   const entries = ['.claude-memory/', '.claude-memory.config.js', '.claude/', '.mcp.json'];
   let content = '';
@@ -187,9 +187,43 @@ function setupGitignore() {
   }
 }
 
-// ── [5/5] Services ──────────────────────────────────────────────────────────
+// ── [5/6] Pre-download embedding model ───────────────────────────────────────
+async function setupModel() {
+  log('[5/6] Preparing embedding model (bge-m3) ...');
+
+  const os = require('os');
+  const cacheDir = path.join(os.homedir(), '.cache', 'huggingface', 'transformers-js');
+  const modelDir = path.join(cacheDir, 'Xenova', 'bge-m3', 'onnx');
+
+  // Check if model is already cached
+  if (fs.existsSync(path.join(modelDir, 'model.onnx_data'))) {
+    const stat = fs.statSync(path.join(modelDir, 'model.onnx_data'));
+    if (stat.size > 300 * 1024 * 1024) { // > 300MB = likely complete
+      ok(`  Model already cached (${(stat.size / 1024 / 1024 / 1024).toFixed(1)}GB).`);
+      return;
+    }
+    warn('  Incomplete model cache detected, re-downloading ...');
+  }
+
+  log('  Downloading model (~2GB, this may take a few minutes) ...');
+  try {
+    // Resolve from package's own dependencies
+    const transformersPath = require.resolve('@huggingface/transformers', { paths: [PKG_DIR] });
+    const { pipeline, env } = await import(transformersPath);
+    env.cacheDir = cacheDir;
+    const extractor = await pipeline('feature-extraction', 'Xenova/bge-m3', { device: 'cpu' });
+    // Quick test to verify model works
+    await extractor('test', { pooling: 'cls', normalize: true });
+    ok('  Model downloaded and verified.');
+  } catch (e) {
+    warn(`  Model download failed: ${e.message}`);
+    warn('  The embedding server will retry on first start.');
+  }
+}
+
+// ── [6/6] Services ──────────────────────────────────────────────────────────
 function setupServices() {
-  log('[5/5] Setting up background services ...');
+  log('[6/6] Setting up background services ...');
 
   // Check if Azure credentials are configured
   let hasCredentials = false;
@@ -411,6 +445,7 @@ async function main() {
   setupMCP();
   setupHooks();
   setupGitignore();
+  await setupModel();
   setupServices();
 }
 

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

@@ -65,7 +65,7 @@ function searchViaEmbedding(query, limit) {
     }, TIMEOUT_MS - 50);
 
     socket.connect(EMBEDDING_PORT, '127.0.0.1', () => {
-      socket.write(JSON.stringify({ action: 'search', query, limit }) + '\n');
+      socket.write(JSON.stringify({ action: 'search', query, limit, dataDir: config.dataDir }) + '\n');
     });
 
     socket.on('data', (data) => {

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

@@ -63,7 +63,7 @@ function searchViaEmbedding(query, limit) {
     }, TIMEOUT_MS - 50);
 
     socket.connect(EMBEDDING_PORT, '127.0.0.1', () => {
-      socket.write(JSON.stringify({ action: 'search', query, limit }) + '\n');
+      socket.write(JSON.stringify({ action: 'search', query, limit, dataDir: config.dataDir }) + '\n');
     });
 
     socket.on('data', (data) => {

package/hooks/user-prompt-hook.js

@@ -53,7 +53,7 @@ function searchViaEmbedding(query, limit) {
     }, SEARCH_TIMEOUT_MS);
 
     socket.connect(EMBEDDING_PORT, '127.0.0.1', () => {
-      socket.write(JSON.stringify({ action: 'search', query, limit }) + '\n');
+      socket.write(JSON.stringify({ action: 'search', query, limit, dataDir: config.dataDir }) + '\n');
     });
 
     socket.on('data', (data) => {

package/lib/embedding-client.js

@@ -20,7 +20,7 @@ function log(msg) {
 
 async function sendRequest(req, timeout = TIMEOUT_MS) {
   const startTime = Date.now();
-  log(`[REQ] action=${req.action} query=${str(req.query)} limit=${req.limit || '-'}`);
+  log(`[REQ] action=${req.action} query=${str(req.query)} limit=${req.limit || '-'} dataDir=${req.dataDir || 'default'}`);
 
   return new Promise((resolve, reject) => {
     const socket = new net.Socket();
@@ -82,13 +82,17 @@ async function sendRequest(req, timeout = TIMEOUT_MS) {
   });
 }
 
-async function search(query, limit = 3, options = {}) {
-  const response = await sendRequest({ action: 'search', query, limit, options });
+async function search(query, limit = 3, options = {}, dataDir = null) {
+  const req = { action: 'search', query, limit, options };
+  if (dataDir) req.dataDir = dataDir;
+  const response = await sendRequest(req);
   return response.results;
 }
 
-async function quickSearch(query, limit = 3, options = {}) {
-  const response = await sendRequest({ action: 'quickSearch', query, limit, options });
+async function quickSearch(query, limit = 3, options = {}, dataDir = null) {
+  const req = { action: 'quickSearch', query, limit, options };
+  if (dataDir) req.dataDir = dataDir;
+  const response = await sendRequest(req);
   return response.results;
 }
 
@@ -101,8 +105,10 @@ async function ping() {
   }
 }
 
-async function getStats() {
-  const response = await sendRequest({ action: 'stats' });
+async function getStats(dataDir = null) {
+  const req = { action: 'stats' };
+  if (dataDir) req.dataDir = dataDir;
+  const response = await sendRequest(req);
   return response.stats;
 }
 

package/lib/memory-db.js

@@ -36,19 +36,17 @@ function tokenize(text) {
 }
 
 const DATA_DIR = config.dataDir;
-const LOG_DIR = config.logDir;
-const DB_PATH = path.join(DATA_DIR, 'memory.db');
-const LOG_FILE = path.join(LOG_DIR, 'memory-db-calls.log');
 
-// Ensure directories exist
+// Ensure default directories exist
 ensureDir(DATA_DIR);
-ensureDir(LOG_DIR);
+ensureDir(path.join(DATA_DIR, 'logs'));
 
 function _str(v) { return v == null ? '' : typeof v === 'string' ? v : JSON.stringify(v); }
 
 function _log(msg) {
+  const logFile = path.join(activeDataDir, 'logs', 'memory-db-calls.log');
   const line = `[${new Date().toISOString()}] ${msg}\n`;
-  try { fs.appendFileSync(LOG_FILE, line); } catch (e) {}
+  try { fs.appendFileSync(logFile, line); } catch (e) {}
 }
 
 // Stopwords
@@ -71,26 +69,36 @@ const STRUCTURIZE_CONFIG = {
 
 // ============== Database Management ==============
 
-let db = null;
+const dbPool = new Map();  // dataDir -> Database
+let activeDataDir = DATA_DIR;  // default to config's dataDir
 let embeddingModel = null;
 
+function setActiveDataDir(dataDir) {
+  activeDataDir = dataDir;
+}
+
 function getDb() {
-  if (db) return db;
+  const dir = activeDataDir;
+  if (dbPool.has(dir)) return dbPool.get(dir);
 
   try {
+    ensureDir(dir);
+    ensureDir(path.join(dir, 'logs'));
+
     const Database = require('better-sqlite3');
-    db = new Database(DB_PATH);
+    const database = new Database(path.join(dir, 'memory.db'));
 
     // Load sqlite-vec extension
     try {
       const sqliteVec = require('sqlite-vec');
-      sqliteVec.load(db);
+      sqliteVec.load(database);
     } catch (e) {
       console.error('[memory-db] Warning: sqlite-vec not loaded:', e.message);
     }
 
-    initTables();
-    return db;
+    dbPool.set(dir, database);  // put in pool before initTables (in case it calls getDb)
+    initTables(database);
+    return database;
   } catch (e) {
     console.error('[memory-db] Failed to initialize database:', e.message);
     throw e;
@@ -98,15 +106,15 @@ function getDb() {
 }
 
 function closeDb() {
-  if (db) {
-    db.close();
-    db = null;
+  for (const [dir, database] of dbPool) {
+    database.close();
   }
+  dbPool.clear();
 }
 
-function initTables() {
+function initTables(database) {
   // Main memories table
-  db.exec(`
+  database.exec(`
     CREATE TABLE IF NOT EXISTS memories (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       content TEXT NOT NULL,
@@ -132,7 +140,7 @@ function initTables() {
 
   // [v4.5] Add structured_content column (if it doesn't exist)
   try {
-    db.exec(`ALTER TABLE memories ADD COLUMN structured_content TEXT`);
+    database.exec(`ALTER TABLE memories ADD COLUMN structured_content TEXT`);
   } catch (e) {
     // Column already exists, ignore
   }
@@ -140,7 +148,7 @@ function initTables() {
   // FTS5 full-text search table (standalone, not external content)
   // Managed manually via ftsInsert/ftsDelete for jieba tokenization support
   try {
-    db.exec(`
+    database.exec(`
       CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
         content, structured_content, summary, tags, keywords
       )
@@ -151,18 +159,18 @@ function initTables() {
 
   // Migrate from external content FTS to standalone FTS if needed
   try {
-    db.exec("DELETE FROM memories_fts WHERE rowid = -1");
+    database.exec("DELETE FROM memories_fts WHERE rowid = -1");
   } catch (e) {
     // External content FTS table detected, rebuild as standalone
-    db.exec('DROP TABLE IF EXISTS memories_fts');
-    db.exec(`
+    database.exec('DROP TABLE IF EXISTS memories_fts');
+    database.exec(`
       CREATE VIRTUAL TABLE memories_fts USING fts5(
         content, structured_content, summary, tags, keywords
       )
     `);
     // Repopulate FTS with tokenized content
-    const rows = db.prepare('SELECT id, content, structured_content, summary, tags, keywords FROM memories').all();
-    const insertFts = db.prepare('INSERT INTO memories_fts(rowid, content, structured_content, summary, tags, keywords) VALUES (?, ?, ?, ?, ?, ?)');
+    const rows = database.prepare('SELECT id, content, structured_content, summary, tags, keywords FROM memories').all();
+    const insertFts = database.prepare('INSERT INTO memories_fts(rowid, content, structured_content, summary, tags, keywords) VALUES (?, ?, ?, ?, ?, ?)');
     for (const r of rows) {
       try {
         insertFts.run(r.id, tokenize(r.content || ''), tokenize(r.structured_content || ''), tokenize(r.summary || ''), tokenize(r.tags || ''), tokenize(r.keywords || ''));
@@ -172,7 +180,7 @@ function initTables() {
 
   // Vector table (if sqlite-vec is available, use cosine distance)
   try {
-    db.exec(`
+    database.exec(`
       CREATE VIRTUAL TABLE IF NOT EXISTS memories_vec USING vec0(
         embedding float[${config.embedding.dimensions}] distance_metric=cosine
       )
@@ -182,7 +190,7 @@ function initTables() {
   }
 
   // Clusters table
-  db.exec(`
+  database.exec(`
     CREATE TABLE IF NOT EXISTS clusters (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       theme TEXT NOT NULL,
@@ -199,7 +207,7 @@ function initTables() {
   `);
 
   // Create indexes
-  db.exec(`
+  database.exec(`
     CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
     CREATE INDEX IF NOT EXISTS idx_memories_domain ON memories(domain);
     CREATE INDEX IF NOT EXISTS idx_memories_confidence ON memories(confidence);
@@ -208,9 +216,9 @@ function initTables() {
   `);
 
   // Drop old FTS triggers (no longer needed with standalone FTS + manual management)
-  db.exec(`DROP TRIGGER IF EXISTS memories_ai`);
-  db.exec(`DROP TRIGGER IF EXISTS memories_ad`);
-  db.exec(`DROP TRIGGER IF EXISTS memories_au`);
+  database.exec(`DROP TRIGGER IF EXISTS memories_ai`);
+  database.exec(`DROP TRIGGER IF EXISTS memories_ad`);
+  database.exec(`DROP TRIGGER IF EXISTS memories_au`);
 }
 
 // ============== FTS Management ==============
@@ -1272,6 +1280,7 @@ module.exports = {
   // Database
   getDb,
   closeDb,
+  setActiveDataDir,
 
   // Core functions
   save,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alex900530/claude-persistent-memory",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "description": "Persistent memory system for Claude Code — hybrid BM25 + vector search, LLM-driven structuring, automatic clustering",
   "main": "lib/memory-db.js",
   "bin": {

package/services/embedding-server.js

@@ -39,16 +39,22 @@ async function handleRequest(data) {
   try {
     const request = JSON.parse(data);
     const startTime = Date.now();
+
+    // Switch to request-specified project database
+    if (request.dataDir) {
+      memoryDb.setActiveDataDir(request.dataDir);
+    }
+
     switch (request.action) {
       case 'search': {
-        log(`[REQ] action=search query=${str(request.query)} limit=${request.limit || 3}`);
+        log(`[REQ] action=search query=${str(request.query)} limit=${request.limit || 3} dataDir=${request.dataDir || 'default'}`);
         const results = await memoryDb.search(request.query, request.limit || 3, request.options || {});
         const duration = Date.now() - startTime;
         log(`[RES] action=search duration=${duration}ms results=${results.length} matches=${results.map(r => '#' + r.id + '(' + (r.vectorSimilarity != null ? r.vectorSimilarity.toFixed(3) : '?') + ')').join(',')}`);
         return { success: true, results };
       }
       case 'quickSearch': {
-        log(`[REQ] action=quickSearch query=${str(request.query)} limit=${request.limit || 3}`);
+        log(`[REQ] action=quickSearch query=${str(request.query)} limit=${request.limit || 3} dataDir=${request.dataDir || 'default'}`);
         const quickResults = memoryDb.quickSearch(request.query, request.limit || 3, request.options || {});
         const duration = Date.now() - startTime;
         log(`[RES] action=quickSearch duration=${duration}ms results=${quickResults.length} matches=${quickResults.map(r => '#' + r.id + '(' + (r.vectorSimilarity != null ? r.vectorSimilarity.toFixed(3) : '?') + ')').join(',')}`);

package/services/memory-mcp-server.js

@@ -30,6 +30,7 @@ const z = require('zod');
 
 // ============ Memory modules ============
 
+const config = require('../config');
 const memoryDb = require('../lib/memory-db');
 
 // Embedding client for hybrid search via embedding server
@@ -55,7 +56,7 @@ async function hybridSearch(query, limit, options = {}) {
   }
 
   if (useEmbeddingService) {
-    return embeddingClient.search(query, limit);
+    return embeddingClient.search(query, limit, options, config.dataDir);
   }
 
   // Fallback: inline hybrid search