claude-memory-layer 1.0.6 → 1.0.8

package/dist/hooks/session-start.js

@@ -67,7 +67,10 @@ function toDate(value) {
     return new Date(value);
   return new Date(String(value));
 }
-function createDatabase(path2) {
+function createDatabase(path2, options) {
+  if (options?.readOnly) {
+    return new duckdb.Database(path2, { access_mode: "READ_ONLY" });
+  }
   return new duckdb.Database(path2);
 }
 function dbRun(db, sql, params = []) {
@@ -121,18 +124,24 @@ function dbClose(db) {
 
 // src/core/event-store.ts
 var EventStore = class {
-  constructor(dbPath) {
+  constructor(dbPath, options) {
     this.dbPath = dbPath;
-    this.db = createDatabase(dbPath);
+    this.readOnly = options?.readOnly ?? false;
+    this.db = createDatabase(dbPath, { readOnly: this.readOnly });
   }
   db;
   initialized = false;
+  readOnly;
   /**
    * Initialize database schema
    */
   async initialize() {
     if (this.initialized)
       return;
+    if (this.readOnly) {
+      this.initialized = true;
+      return;
+    }
     await dbRun(this.db, `
       CREATE TABLE IF NOT EXISTS events (
         id VARCHAR PRIMARY KEY,
@@ -609,6 +618,36 @@ var EventStore = class {
     );
     return rows;
   }
+  /**
+   * Get events by memory level
+   */
+  async getEventsByLevel(level, options) {
+    await this.initialize();
+    const limit = options?.limit || 50;
+    const offset = options?.offset || 0;
+    const rows = await dbAll(
+      this.db,
+      `SELECT e.* FROM events e
+       INNER JOIN memory_levels ml ON e.id = ml.event_id
+       WHERE ml.level = ?
+       ORDER BY e.timestamp DESC
+       LIMIT ? OFFSET ?`,
+      [level, limit, offset]
+    );
+    return rows.map((row) => this.rowToEvent(row));
+  }
+  /**
+   * Get memory level for a specific event
+   */
+  async getEventLevel(eventId) {
+    await this.initialize();
+    const rows = await dbAll(
+      this.db,
+      `SELECT level FROM memory_levels WHERE event_id = ?`,
+      [eventId]
+    );
+    return rows.length > 0 ? rows[0].level : null;
+  }
   // ============================================================
   // Endless Mode Helper Methods
   // ============================================================
@@ -1191,6 +1230,7 @@ var Retriever = class {
   matcher;
   sharedStore;
   sharedVectorStore;
+  graduation;
   constructor(eventStore, vectorStore, embedder, matcher, sharedOptions) {
     this.eventStore = eventStore;
     this.vectorStore = vectorStore;
@@ -1199,6 +1239,12 @@ var Retriever = class {
     this.sharedStore = sharedOptions?.sharedStore;
     this.sharedVectorStore = sharedOptions?.sharedVectorStore;
   }
+  /**
+   * Set graduation pipeline for access tracking
+   */
+  setGraduationPipeline(graduation) {
+    this.graduation = graduation;
+  }
   /**
    * Set shared stores after construction
    */
@@ -1321,6 +1367,13 @@ var Retriever = class {
       const event = await this.eventStore.getEvent(result.eventId);
       if (!event)
         continue;
+      if (this.graduation) {
+        this.graduation.recordAccess(
+          event.id,
+          options.sessionId || "unknown",
+          result.score
+        );
+      }
       let sessionContext;
       if (options.includeSessionContext) {
         sessionContext = await this.getSessionContext(event.sessionId, event.id);
@@ -1442,15 +1495,26 @@ var GraduationPipeline = class {
       L3toL4: { ...DEFAULT_CRITERIA.L3toL4, ...criteria.L3toL4 }
     };
   }
+  // Track which sessions have accessed each event
+  sessionAccesses = /* @__PURE__ */ new Map();
   /**
    * Record an access to an event (used for graduation scoring)
    */
   recordAccess(eventId, fromSessionId, confidence = 1) {
     const existing = this.metrics.get(eventId);
+    if (!this.sessionAccesses.has(eventId)) {
+      this.sessionAccesses.set(eventId, /* @__PURE__ */ new Set());
+    }
+    const sessions = this.sessionAccesses.get(eventId);
+    const isNewSession = !sessions.has(fromSessionId);
+    sessions.add(fromSessionId);
     if (existing) {
       existing.accessCount++;
       existing.lastAccessed = /* @__PURE__ */ new Date();
       existing.confidence = Math.max(existing.confidence, confidence);
+      if (isNewSession && sessions.size > 1) {
+        existing.crossSessionRefs = sessions.size - 1;
+      }
     } else {
       this.metrics.set(eventId, {
         eventId,
@@ -3338,6 +3402,127 @@ function createContinuityManager(eventStore, config) {
   return new ContinuityManager(eventStore, config);
 }
 
+// src/core/graduation-worker.ts
+var DEFAULT_CONFIG4 = {
+  evaluationIntervalMs: 3e5,
+  // 5 minutes
+  batchSize: 50,
+  cooldownMs: 36e5
+  // 1 hour cooldown between evaluations
+};
+var GraduationWorker = class {
+  constructor(eventStore, graduation, config = DEFAULT_CONFIG4) {
+    this.eventStore = eventStore;
+    this.graduation = graduation;
+    this.config = config;
+  }
+  running = false;
+  timeout = null;
+  lastEvaluated = /* @__PURE__ */ new Map();
+  /**
+   * Start the graduation worker
+   */
+  start() {
+    if (this.running)
+      return;
+    this.running = true;
+    this.scheduleNext();
+  }
+  /**
+   * Stop the graduation worker
+   */
+  stop() {
+    this.running = false;
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+  }
+  /**
+   * Check if currently running
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Force a graduation evaluation run
+   */
+  async forceRun() {
+    return await this.runGraduation();
+  }
+  /**
+   * Schedule the next graduation check
+   */
+  scheduleNext() {
+    if (!this.running)
+      return;
+    this.timeout = setTimeout(
+      () => this.run(),
+      this.config.evaluationIntervalMs
+    );
+  }
+  /**
+   * Run graduation evaluation
+   */
+  async run() {
+    if (!this.running)
+      return;
+    try {
+      await this.runGraduation();
+    } catch (error) {
+      console.error("Graduation error:", error);
+    }
+    this.scheduleNext();
+  }
+  /**
+   * Perform graduation evaluation across all levels
+   */
+  async runGraduation() {
+    const result = {
+      evaluated: 0,
+      graduated: 0,
+      byLevel: {}
+    };
+    const levels = ["L0", "L1", "L2", "L3"];
+    const now = Date.now();
+    for (const level of levels) {
+      const events = await this.eventStore.getEventsByLevel(level, {
+        limit: this.config.batchSize
+      });
+      let levelGraduated = 0;
+      for (const event of events) {
+        const lastEval = this.lastEvaluated.get(event.id);
+        if (lastEval && now - lastEval < this.config.cooldownMs) {
+          continue;
+        }
+        result.evaluated++;
+        this.lastEvaluated.set(event.id, now);
+        const gradResult = await this.graduation.evaluateGraduation(event.id, level);
+        if (gradResult.success) {
+          result.graduated++;
+          levelGraduated++;
+        }
+      }
+      if (levelGraduated > 0) {
+        result.byLevel[level] = levelGraduated;
+      }
+    }
+    if (this.lastEvaluated.size > 1e3) {
+      const entries = Array.from(this.lastEvaluated.entries());
+      entries.sort((a, b) => b[1] - a[1]);
+      this.lastEvaluated = new Map(entries.slice(0, 1e3));
+    }
+    return result;
+  }
+};
+function createGraduationWorker(eventStore, graduation, config) {
+  return new GraduationWorker(
+    eventStore,
+    graduation,
+    { ...DEFAULT_CONFIG4, ...config }
+  );
+}
+
 // src/services/memory-service.ts
 function normalizePath(projectPath) {
   const expanded = projectPath.startsWith("~") ? path.join(os.homedir(), projectPath.slice(1)) : projectPath;
@@ -3401,6 +3586,7 @@ var MemoryService = class {
   retriever;
   graduation;
   vectorWorker = null;
+  graduationWorker = null;
   initialized = false;
   // Endless Mode components
   workingSetStore = null;
@@ -3415,14 +3601,16 @@ var MemoryService = class {
   sharedPromoter = null;
   sharedStoreConfig = null;
   projectHash = null;
+  readOnly;
   constructor(config) {
     const storagePath = this.expandPath(config.storagePath);
-    if (!fs.existsSync(storagePath)) {
+    this.readOnly = config.readOnly ?? false;
+    if (!this.readOnly && !fs.existsSync(storagePath)) {
       fs.mkdirSync(storagePath, { recursive: true });
     }
     this.projectHash = config.projectHash || null;
     this.sharedStoreConfig = config.sharedStoreConfig ?? { enabled: true };
-    this.eventStore = new EventStore(path.join(storagePath, "events.duckdb"));
+    this.eventStore = new EventStore(path.join(storagePath, "events.duckdb"), { readOnly: this.readOnly });
     this.vectorStore = new VectorStore(path.join(storagePath, "vectors"));
     this.embedder = config.embeddingModel ? new Embedder(config.embeddingModel) : getDefaultEmbedder();
     this.matcher = getDefaultMatcher();
@@ -3443,19 +3631,27 @@ var MemoryService = class {
     await this.eventStore.initialize();
     await this.vectorStore.initialize();
     await this.embedder.initialize();
-    this.vectorWorker = createVectorWorker(
-      this.eventStore,
-      this.vectorStore,
-      this.embedder
-    );
-    this.vectorWorker.start();
-    const savedMode = await this.eventStore.getEndlessConfig("mode");
-    if (savedMode === "endless") {
-      this.endlessMode = "endless";
-      await this.initializeEndlessMode();
-    }
-    if (this.sharedStoreConfig?.enabled !== false) {
-      await this.initializeSharedStore();
+    if (!this.readOnly) {
+      this.vectorWorker = createVectorWorker(
+        this.eventStore,
+        this.vectorStore,
+        this.embedder
+      );
+      this.vectorWorker.start();
+      this.retriever.setGraduationPipeline(this.graduation);
+      this.graduationWorker = createGraduationWorker(
+        this.eventStore,
+        this.graduation
+      );
+      this.graduationWorker.start();
+      const savedMode = await this.eventStore.getEndlessConfig("mode");
+      if (savedMode === "endless") {
+        this.endlessMode = "endless";
+        await this.initializeEndlessMode();
+      }
+      if (this.sharedStoreConfig?.enabled !== false) {
+        await this.initializeSharedStore();
+      }
     }
     this.initialized = true;
   }
@@ -3636,6 +3832,20 @@ var MemoryService = class {
     }
     return 0;
   }
+  /**
+   * Get events by memory level
+   */
+  async getEventsByLevel(level, options) {
+    await this.initialize();
+    return this.eventStore.getEventsByLevel(level, options);
+  }
+  /**
+   * Get memory level for a specific event
+   */
+  async getEventLevel(eventId) {
+    await this.initialize();
+    return this.eventStore.getEventLevel(eventId);
+  }
   /**
    * Format retrieval results as context for Claude
    */
@@ -3818,6 +4028,22 @@ var MemoryService = class {
       return [];
     return this.consolidatedStore.getAll({ limit });
   }
+  /**
+   * Get most accessed consolidated memories
+   */
+  async getMostAccessedMemories(limit = 10) {
+    if (!this.consolidatedStore)
+      return [];
+    return this.consolidatedStore.getMostAccessed(limit);
+  }
+  /**
+   * Mark a consolidated memory as accessed
+   */
+  async markMemoryAccessed(memoryId) {
+    if (!this.consolidatedStore)
+      return;
+    await this.consolidatedStore.markAccessed(memoryId);
+  }
   /**
    * Calculate continuity score for current context
    */
@@ -3905,10 +4131,28 @@ var MemoryService = class {
     }
     return parts.join("\n");
   }
+  /**
+   * Force a graduation evaluation run
+   */
+  async forceGraduation() {
+    if (!this.graduationWorker) {
+      return { evaluated: 0, graduated: 0, byLevel: {} };
+    }
+    return this.graduationWorker.forceRun();
+  }
+  /**
+   * Record access to a memory event (for graduation scoring)
+   */
+  recordMemoryAccess(eventId, sessionId, confidence = 1) {
+    this.graduation.recordAccess(eventId, sessionId, confidence);
+  }
   /**
    * Shutdown service
    */
   async shutdown() {
+    if (this.graduationWorker) {
+      this.graduationWorker.stop();
+    }
     if (this.consolidationWorker) {
       this.consolidationWorker.stop();
     }