claude-memory-layer 1.0.9 → 1.0.10

package/dist/server/index.js

@@ -1048,6 +1048,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);
@@ -1488,6 +1510,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
    */
@@ -4546,9 +4624,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 });
     }
@@ -4595,6 +4675,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();
@@ -4764,9 +4848,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,
@@ -4776,6 +4857,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
    */