claude-memory-layer 1.0.9 → 1.0.10

package/dist/hooks/user-prompt-submit.js

@@ -1034,6 +1034,28 @@ var SQLiteEventStore = class {
       CREATE INDEX IF NOT EXISTS idx_consolidated_confidence ON consolidated_memories(confidence);
       CREATE INDEX IF NOT EXISTS idx_continuity_created ON continuity_log(created_at);
       CREATE INDEX IF NOT EXISTS idx_embedding_outbox_status ON embedding_outbox(status);
+
+      -- FTS5 Full-Text Search for fast keyword search
+      CREATE VIRTUAL TABLE IF NOT EXISTS events_fts USING fts5(
+        content,
+        event_id UNINDEXED,
+        content='events',
+        content_rowid='rowid'
+      );
+
+      -- Triggers to keep FTS in sync with events table
+      CREATE TRIGGER IF NOT EXISTS events_fts_insert AFTER INSERT ON events BEGIN
+        INSERT INTO events_fts(rowid, content, event_id) VALUES (NEW.rowid, NEW.content, NEW.id);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS events_fts_delete AFTER DELETE ON events BEGIN
+        INSERT INTO events_fts(events_fts, rowid, content, event_id) VALUES('delete', OLD.rowid, OLD.content, OLD.id);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS events_fts_update AFTER UPDATE ON events BEGIN
+        INSERT INTO events_fts(events_fts, rowid, content, event_id) VALUES('delete', OLD.rowid, OLD.content, OLD.id);
+        INSERT INTO events_fts(rowid, content, event_id) VALUES (NEW.rowid, NEW.content, NEW.id);
+      END;
     `);
     const tableInfo = sqliteAll(this.db, "PRAGMA table_info(events)", []);
     const columnNames = tableInfo.map((col) => col.name);
@@ -1474,6 +1496,62 @@ var SQLiteEventStore = class {
     );
     return rows.map((row) => this.rowToEvent(row));
   }
+  /**
+   * Fast keyword search using FTS5
+   * Returns events matching the search query, ranked by relevance
+   */
+  async keywordSearch(query, limit = 10) {
+    await this.initialize();
+    const searchTerms = query.replace(/['"(){}[\]^~*?:\\/-]/g, " ").split(/\s+/).filter((term) => term.length > 1).map((term) => `"${term}"*`).join(" OR ");
+    if (!searchTerms) {
+      return [];
+    }
+    try {
+      const rows = sqliteAll(
+        this.db,
+        `SELECT e.*, fts.rank
+         FROM events_fts fts
+         JOIN events e ON e.id = fts.event_id
+         WHERE events_fts MATCH ?
+         ORDER BY fts.rank
+         LIMIT ?`,
+        [searchTerms, limit]
+      );
+      return rows.map((row) => ({
+        event: this.rowToEvent(row),
+        rank: row.rank
+      }));
+    } catch (error) {
+      const likePattern = `%${query}%`;
+      const rows = sqliteAll(
+        this.db,
+        `SELECT *, 0 as rank FROM events
+         WHERE content LIKE ?
+         ORDER BY timestamp DESC
+         LIMIT ?`,
+        [likePattern, limit]
+      );
+      return rows.map((row) => ({
+        event: this.rowToEvent(row),
+        rank: 0
+      }));
+    }
+  }
+  /**
+   * Rebuild FTS index from existing events
+   * Call this once after upgrading to FTS5
+   */
+  async rebuildFtsIndex() {
+    await this.initialize();
+    const countRow = sqliteGet(this.db, "SELECT COUNT(*) as count FROM events", []);
+    const totalEvents = countRow?.count ?? 0;
+    sqliteExec(this.db, `
+      DELETE FROM events_fts;
+      INSERT INTO events_fts(rowid, content, event_id)
+      SELECT rowid, content, id FROM events;
+    `);
+    return totalEvents;
+  }
   /**
    * Get database instance for direct access
    */
@@ -4547,9 +4625,11 @@ var MemoryService = class {
   sharedStoreConfig = null;
   projectHash = null;
   readOnly;
+  lightweightMode;
   constructor(config) {
     const storagePath = this.expandPath(config.storagePath);
     this.readOnly = config.readOnly ?? false;
+    this.lightweightMode = config.lightweightMode ?? false;
     if (!this.readOnly && !fs.existsSync(storagePath)) {
       fs.mkdirSync(storagePath, { recursive: true });
     }
@@ -4596,6 +4676,10 @@ var MemoryService = class {
     if (this.initialized)
       return;
     await this.sqliteStore.initialize();
+    if (this.lightweightMode) {
+      this.initialized = true;
+      return;
+    }
     if (this.analyticsStore) {
       try {
         await this.analyticsStore.initialize();
@@ -4765,9 +4849,6 @@ var MemoryService = class {
    */
   async retrieveMemories(query, options) {
     await this.initialize();
-    if (this.vectorWorker) {
-      await this.vectorWorker.processAll();
-    }
     if (options?.includeShared && this.sharedStore) {
       return this.retriever.retrieveUnified(query, {
         ...options,
@@ -4777,6 +4858,29 @@ var MemoryService = class {
     }
     return this.retriever.retrieve(query, options);
   }
+  /**
+   * Fast keyword search using SQLite FTS5
+   * Much faster than vector search - no embedding model needed
+   */
+  async keywordSearch(query, options) {
+    await this.initialize();
+    const results = await this.sqliteStore.keywordSearch(query, options?.topK ?? 10);
+    const maxRank = Math.min(...results.map((r) => r.rank), -1e-3);
+    const minRank = Math.max(...results.map((r) => r.rank), -1e3);
+    const rankRange = maxRank - minRank || 1;
+    return results.map((r) => ({
+      event: r.event,
+      score: 1 - (r.rank - minRank) / rankRange
+      // Normalize to 0-1
+    })).filter((r) => !options?.minScore || r.score >= options.minScore);
+  }
+  /**
+   * Rebuild FTS index (call after database upgrade)
+   */
+  async rebuildFtsIndex() {
+    await this.initialize();
+    return this.sqliteStore.rebuildFtsIndex();
+  }
   /**
    * Get session history
    */
@@ -5200,94 +5304,60 @@ var MemoryService = class {
   }
 };
 var serviceCache = /* @__PURE__ */ new Map();
-var GLOBAL_KEY = "__global__";
-function getDefaultMemoryService() {
-  if (!serviceCache.has(GLOBAL_KEY)) {
-    serviceCache.set(GLOBAL_KEY, new MemoryService({
-      storagePath: "~/.claude-code/memory",
+function getLightweightMemoryService(sessionId) {
+  const projectInfo = getSessionProject(sessionId);
+  const key = projectInfo ? `lightweight_${projectInfo.projectHash}` : "lightweight_global";
+  if (!serviceCache.has(key)) {
+    const storagePath = projectInfo ? getProjectStoragePath(projectInfo.projectPath) : path.join(os.homedir(), ".claude-code", "memory");
+    serviceCache.set(key, new MemoryService({
+      storagePath,
+      projectHash: projectInfo?.projectHash,
+      lightweightMode: true,
+      // Skip embedder/vector/workers
       analyticsEnabled: false,
-      // Hooks don't need DuckDB
       sharedStoreConfig: { enabled: false }
-      // Shared store uses DuckDB too
     }));
   }
-  return serviceCache.get(GLOBAL_KEY);
-}
-function getMemoryServiceForProject(projectPath, sharedStoreConfig) {
-  const hash = hashProjectPath(projectPath);
-  if (!serviceCache.has(hash)) {
-    const storagePath = getProjectStoragePath(projectPath);
-    serviceCache.set(hash, new MemoryService({
-      storagePath,
-      projectHash: hash,
-      // Override shared store config - hooks don't need DuckDB
-      sharedStoreConfig: sharedStoreConfig ?? { enabled: false },
-      analyticsEnabled: false
-      // Hooks don't need DuckDB
-    }));
-  }
-  return serviceCache.get(hash);
-}
-function getMemoryServiceForSession(sessionId) {
-  const projectInfo = getSessionProject(sessionId);
-  if (projectInfo) {
-    return getMemoryServiceForProject(projectInfo.projectPath);
-  }
-  return getDefaultMemoryService();
+  return serviceCache.get(key);
 }
 
 // src/hooks/user-prompt-submit.ts
+var MAX_MEMORIES = parseInt(process.env.CLAUDE_MEMORY_MAX_COUNT || "5");
+var MIN_SCORE = parseFloat(process.env.CLAUDE_MEMORY_MIN_SCORE || "0.3");
+var ENABLE_SEARCH = process.env.CLAUDE_MEMORY_SEARCH !== "false";
 async function main() {
   const inputData = await readStdin();
   const input = JSON.parse(inputData);
-  const memoryService = getMemoryServiceForSession(input.session_id);
-  const config = {
-    candidateCount: parseInt(process.env.CLAUDE_MEMORY_CANDIDATES || "10"),
-    minScore: parseFloat(process.env.CLAUDE_MEMORY_MIN_SCORE || "0.7"),
-    maxMemories: parseInt(process.env.CLAUDE_MEMORY_MAX_COUNT || "5"),
-    dynamicThresholdRatio: parseFloat(process.env.CLAUDE_MEMORY_THRESHOLD_RATIO || "0.85"),
-    strictMinScore: parseFloat(process.env.CLAUDE_MEMORY_STRICT_MIN || "0.75")
-  };
+  const memoryService = getLightweightMemoryService(input.session_id);
   try {
-    const includeShared = memoryService.isSharedStoreEnabled();
-    const retrievalResult = await memoryService.retrieveMemories(input.prompt, {
-      topK: config.candidateCount,
-      // Get more candidates initially
-      minScore: config.minScore,
-      includeShared
-    });
     await memoryService.storeUserPrompt(
       input.session_id,
       input.prompt
     );
-    let relevantMemories = [];
-    if (retrievalResult.memories && retrievalResult.memories.length > 0) {
-      const bestScore = Math.max(...retrievalResult.memories.map((m) => m.score));
-      const dynamicThreshold = Math.max(config.strictMinScore, bestScore * config.dynamicThresholdRatio);
-      relevantMemories = retrievalResult.memories.filter((m) => m.score >= dynamicThreshold);
-      relevantMemories = relevantMemories.slice(0, config.maxMemories);
-      if (relevantMemories.length === 0) {
-        const fallbackCount = Math.min(3, config.maxMemories);
-        relevantMemories = retrievalResult.memories.filter((m) => m.score >= config.minScore).slice(0, fallbackCount);
-      }
-      if (process.env.CLAUDE_MEMORY_DEBUG) {
-        console.error(`Memory filtering: ${retrievalResult.memories.length} candidates -> ${relevantMemories.length} selected`);
-        console.error(`Threshold: ${dynamicThreshold.toFixed(3)}, Best score: ${bestScore.toFixed(3)}`);
-      }
-      if (relevantMemories.length > 0) {
-        const eventIds = relevantMemories.map((m) => m.event.id);
+    let context = "";
+    if (ENABLE_SEARCH && input.prompt.length > 10) {
+      const results = await memoryService.keywordSearch(input.prompt, {
+        topK: MAX_MEMORIES,
+        minScore: MIN_SCORE
+      });
+      if (results.length > 0) {
+        const eventIds = results.map((r) => r.event.id);
         await memoryService.incrementMemoryAccess(eventIds);
+        const memories = results.map((r) => {
+          const preview = r.event.content.length > 300 ? r.event.content.substring(0, 300) + "..." : r.event.content;
+          return `- [${r.event.eventType}] ${preview}`;
+        });
+        context = `\u{1F4A1} **Related memories found:**
+
+${memories.join("\n\n")}`;
       }
     }
-    const filteredResult = {
-      ...retrievalResult,
-      memories: relevantMemories
-    };
-    const context = memoryService.formatAsContext(filteredResult);
     const output = { context };
     console.log(JSON.stringify(output));
   } catch (error) {
-    console.error("Memory hook error:", error);
+    if (process.env.CLAUDE_MEMORY_DEBUG) {
+      console.error("Memory hook error:", error);
+    }
     console.log(JSON.stringify({ context: "" }));
   }
 }